mdarray 0.5.3-java → 0.5.4-java

data/lib/netcdf/group.rb

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+class NetCDF
+  
+  ########################################################################################
+  # A Group is a logical collection of Variables. The Groups in a Dataset form a 
+  # hierarchical tree, like directories on a disk. A Group has a name and optionally a 
+  # set of Attributes. There is always at least one Group in a dataset, the root Group, 
+  # whose name is the empty string.
+  #
+  # Immutable if setImmutable() was called.
+  ########################################################################################
+
+  class Group < CDMNode
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def common_parent(group)
+      @netcdf_elmt.commomParent(group.netcdf_elmt)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def find_attribute(name, ignore_case = false)
+      if (ignore_case)
+        NetCDF::Attribute.new(@netcdf_elmt.findAttributeIgnoreCase(name))
+      else
+        NetCDF::Attribute.new(@netcdf_elmt.findAttribute(name))
+      end
+    end
+
+    #------------------------------------------------------------------------------------
+    # Retrieve a Dimension using its (short) name. If local is true, then
+    # retrieve a Dimension using its (short) name, in this group only.
+    #------------------------------------------------------------------------------------
+
+    def find_dimension(name, local = false)
+      if (local)
+        NetCDF::Dimension.new(@netcdf_elmt.findDimensionLocal(name))
+      else
+        NetCDF::Dimension.new(@netcdf_elmt.findDimension(name))
+      end
+    end
+
+    #------------------------------------------------------------------------------------
+    # Retrieve the Group with the specified (short) name.
+    #------------------------------------------------------------------------------------
+
+    def find_group(name)
+      NetCDF::Group.new(@netcdf_elmt.findGroup(name))
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def find_variable(name, local = true)
+
+      if (local)
+        NetCDF::Variable.new(@netcdf_elmt.findVariable(name))
+      else
+        NetCDF::Variable.new(@netcdf_elmt.findVariableOrInParent(name))
+      end
+
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def attributes
+
+      java_attributes = @netcdf_elmt.getAttributes()
+      attributes = Array.new
+      java_attributes.each do |att|
+        attributes << NetCDF::Attribute.new(att)
+      end
+      attributes
+
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def to_string
+      @netcdf_elmt.toString()
+    end
+
+  end
+
+  #=======================================================================================
+  # GroupWriter is a group that allows for writing data on it.
+  #=======================================================================================
+
+  class GroupWriter < Group
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def add_attribute(attribute)
+      @netcdf_elmt.addAttribute(attribute.netcdf_elmt)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def add_dimension(dimension)
+      @netcdf_elmt.addDimension(dimension.netcdf_elmt)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def add_dimension_if_not_exists(dimension)
+      @netcdf_elmt.addDimensionIfNotExists(dimension.netcdf_elmt)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def add_group(group)
+      @netcdf_elmt.addGroup(group.netcdf_elmt)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def add_variable(variable)
+      @netcdf_elmt.addVariable(variable.netcdf_elmt)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def remove(elmt)
+      @netcdf_elmt.remove(elmt.netcdf_elmt)
+    end
+
+    #------------------------------------------------------------------------------------
+    # remove a Dimension using its name, in this group only
+    #------------------------------------------------------------------------------------
+
+    def remove_dimension(name)
+      @netcdf_elmt.removeDimension(name)
+    end
+
+    #------------------------------------------------------------------------------------
+    # remove a Variable using its (short) name, in this group only
+    #------------------------------------------------------------------------------------
+
+    def remove_variable(name)
+      @netcdf_elmt.removeVariable(name)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def name=(name)
+      @netcdf_elmt.setName(name)
+    end
+
+    #------------------------------------------------------------------------------------
+    # Set the Group's parent Group
+    #------------------------------------------------------------------------------------
+
+    def parent_group=(parent)
+      @netcdf_elmt.setParentGroup(parent.netcdf_elmt)
+    end
+
+
+  end # GroupWriter
+
+
+end

data/lib/netcdf/netcdf.rb

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+
+#======================================================================================
+#
+#======================================================================================
+
+class NetCDF
+  include_package "ucar.nc2"
+  include_package "ucar.ma2"
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def self.define(home_dir, file_name, version, outside_scope = nil, &block)
+
+    writer = NetCDF::FileWriter.new_file(home_dir, file_name, version, outside_scope)
+    begin
+      writer.open
+      writer.instance_eval(&block)
+      writer.create
+      writer.close
+      writer
+    rescue
+      writer.close
+      raise "Illegal opperation occured on file: #{writer.file_name}"
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def self.redefine(home_dir, file_name, outside_scope = nil, &block)
+
+    writer = NetCDF::FileWriter.existing_file(home_dir, file_name, outside_scope)
+    begin
+      writer.open
+      writer.redefine = true
+      # we are not really adding a root group, but actually getting the root group
+      # can only be done in define mode
+      writer.add_root_group
+      writer.instance_eval(&block)
+      writer.redefine = false
+      writer.close
+      writer
+    rescue Exception =>e
+      writer.close
+      p e.message
+      # p e.backtrace.inspect
+      # raise "Illegal opperation occured on file: #{writer.file_name}"
+      raise e
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def self.write(home_dir, file_name, outside_scope = nil, &block)
+
+    writer = NetCDF::FileWriter.existing_file(home_dir, file_name, outside_scope)
+
+    begin
+      writer.open
+      writer.instance_eval(&block)
+      writer.close
+      writer
+    rescue Exception => e
+      writer.close
+      # raise "Illegal opperation occured on file: #{file_name}"
+      raise e
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def self.read(home_dir, file_name, outside_scope = nil, &block)
+
+    reader = NetCDF::File.new(home_dir, file_name, outside_scope)
+    begin
+      reader.open
+      reader.instance_eval(&block)
+      reader.close
+      reader
+    rescue Exception => e
+      reader.close
+      p e.message
+      # raise "Illegal opperation occured on file: #{file_name}"
+      raise e
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  # Outputs the data format
+  #------------------------------------------------------------------------------------
+  
+  def self.output(file_name)
+    print `ncdump #{file_name}`
+  end
+  
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+  
+  def self.get_dtype(type)
+    DataType.valueOf(type.upcase)
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+  
+  def self.writer_version(name)
+    NetcdfFileWriter::Version.valueOf(name)
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+end # NetCDF
+
+require_relative 'cdm_node'
+require_relative 'file'

data/lib/netcdf/variable.rb

@@ -0,0 +1,520 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+class NetCDF
+
+  #=======================================================================================
+  # A Variable is a logical container for data. It has a dataType, a set of Dimensions 
+  # that define its array shape, and optionally a set of Attributes. The data is a 
+  # multidimensional array of primitive types, Strings, or Structures. Data access is 
+  # done through the read() methods, which return a memory resident Array.
+  # Immutable if setImmutable() was called.
+  #=======================================================================================
+
+  class Variable < CDMNode
+
+    attr_reader :attributes
+    attr_reader :dimensions
+    attr_reader :index_iterator
+
+    #------------------------------------------------------------------------------------
+    # 
+    #------------------------------------------------------------------------------------
+
+    def extra_info
+      @netcdf_elmt.extraInfo()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Create a new data cache, use this when you dont want to share the cache.
+    #------------------------------------------------------------------------------------
+
+    def create_new_cache
+      @netcdf_elmt.createNewCache()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Finds an attribute by name
+    #------------------------------------------------------------------------------------
+
+    def find_attribute(name, ignore_case = false)
+
+      if (ignore_case)
+        @netcdf_elmt.findAttributeIgnoreCase(name)
+      else
+        @netcdf_elmt.findAttribute(name)
+      end
+
+    end
+
+    #------------------------------------------------------------------------------------
+    # Find the index of the named Dimension in this Variable.
+    #------------------------------------------------------------------------------------
+
+    def find_dimension_index(name)
+      @netcdf_elmt.findDimensionIndex(name)
+    end
+
+    #------------------------------------------------------------------------------------
+    # Returns the set of attributes for this variable.
+    #------------------------------------------------------------------------------------
+
+    def find_attributes
+
+      attributes = @netcdf_elmt.getAttributes()
+      atts = Array.new
+      attributes.each do |att|
+        atts << NetCDF::Attribute.new(att)
+      end
+      atts
+
+    end
+
+    #------------------------------------------------------------------------------------
+    # Gets the variable data_type
+    #------------------------------------------------------------------------------------
+
+    def get_data_type
+      @netcdf_elmt.getDataType().toString()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Get the description of the Variable.
+    #------------------------------------------------------------------------------------
+
+    def get_description
+      @netcdf_elmt.getDescription()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Get the ith dimension.
+    #------------------------------------------------------------------------------------
+
+    def get_dimension(index)
+      @netcdf_elmt.getDimension(index)
+    end
+
+    #------------------------------------------------------------------------------------
+    # Get the list of dimensions used by this variable.
+    #------------------------------------------------------------------------------------
+
+    def find_dimensions
+
+      dimensions = @netcdf_elmt.getDimensions()
+      dims = Array.new
+      dimensions.each do |dim|
+        dims << NetCDF::Dimension.new(dim)
+      end
+      dims
+
+    end
+
+    #------------------------------------------------------------------------------------
+    # Get the list of Dimension names, space delineated.
+    #------------------------------------------------------------------------------------
+
+    def get_dimensions_string
+      @netcdf_elmt.getDimensionsString()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Get the number of bytes for one element of this Variable.
+    #------------------------------------------------------------------------------------
+
+    def get_element_size
+      @netcdf_elmt.getElementSize()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Get the display name plus the dimensions, eg 'float name(dim1, dim2)'
+    #------------------------------------------------------------------------------------
+
+    def get_name_and_dimensions
+      @netcdf_elmt.getNameAndDimensions()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Get the number of dimensions of the Variable.
+    #------------------------------------------------------------------------------------
+
+    def get_rank
+      @netcdf_elmt.getRank()
+    end
+
+    alias :rank :get_rank
+
+    #------------------------------------------------------------------------------------
+    # Get the shape: length of Variable in each dimension.
+    #------------------------------------------------------------------------------------
+
+    def get_shape(index = nil)
+      if (index)
+        @netcdf_elmt.getShape(index)
+      else
+        @netcdf_elmt.getShape().to_a
+      end
+    end
+
+    alias :shape :get_shape
+
+    #------------------------------------------------------------------------------------
+    # Get the total number of elements in the Variable.
+    #------------------------------------------------------------------------------------
+
+    def get_size
+      @netcdf_elmt.getSize()
+    end
+
+    alias :size :get_size
+
+    #------------------------------------------------------------------------------------
+    # Get the Unit String for the Variable.
+    #------------------------------------------------------------------------------------
+
+    def get_units_string
+      @netcdf_elmt.getUnitsString()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Has data been read and cached.
+    #------------------------------------------------------------------------------------
+
+    def cached_data?
+      @netcdf_elmt.hasCachedData()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Invalidate the data cache
+    #------------------------------------------------------------------------------------
+
+    def invalidate_cache
+      @netcdf_elmt.invalidateCache()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Will this Variable be cached when read.
+    #------------------------------------------------------------------------------------
+
+    def caching?
+      @netcdf_elmt.isCaching()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Calculate if this is a classic coordinate variable: has same name as its first 
+    # dimension.
+    #------------------------------------------------------------------------------------
+
+    def coordinate_variable?
+      @netcdf_elmt.isCoordinateVariable()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Is this Variable immutable
+    #------------------------------------------------------------------------------------
+    
+    def immutable?
+      @netcdf_elmt.isImmutable()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Is this variable metadata?.
+    #------------------------------------------------------------------------------------
+
+    def metadata?
+      @netcdf_elmt.isMetadata()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Whether this is a scalar Variable (rank == 0).
+    #------------------------------------------------------------------------------------
+
+    def scalar?
+      @netcdf_elmt.isScalar()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Can this variable's size grow?.
+    #------------------------------------------------------------------------------------
+
+    def unlimited?
+      @netcdf_elmt.isUnlimited()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Is this Variable unsigned?.
+    #------------------------------------------------------------------------------------
+
+    def unsigned?
+      @netcdf_elmt.isUnsigned()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Does this variable have a variable length dimension? If so, it has as one of its 
+    # mensions Dimension.VLEN.
+    #------------------------------------------------------------------------------------
+
+    def variable_length?
+      @netcdf_elmt.isVariableLength()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Reads data for this Variable and sets the variable @data to the memory resident 
+    # array.
+    # <tt>:origin</tt> int array with the origin of data to be read
+    # <tt>:shape</tt> int array with the shape of the data to be read.  If origin or 
+    #------------------------------------------------------------------------------------
+
+    def read(*args)
+
+      opts = Map.options(args)
+      spec = opts.getopt(:spec)
+      origin = opts.getopt(:origin)
+      shape = opts.getopt(:shape)
+
+      if (origin || shape)
+        MDArray.build_from_nc_array(nil, @netcdf_elmt.read(origin.to_java(:int), 
+                                                           shape.to_java(:int)))
+      elsif (spec)
+        MDArray.build_from_nc_array(nil, @netcdf_elmt.read(spec))
+      else
+        MDArray.build_from_nc_array(nil, @netcdf_elmt.read())
+      end
+      
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def read_scalar(type = nil)
+
+      if (!type)
+        type = get_data_type
+      end
+
+      case type
+      when "double"
+        @netcdf_elmt.readScalarDouble()
+      when "float"
+        @netcdf_elmt.readScalarFloat()
+      when "long"
+        @netcdf_elmt.readScalarLong()
+      when "int"
+        @netcdf_elmt.readScalarInt()
+      when "short"
+        @netcdf_elmt.readScalarShort()
+      when "byte"
+        @netcdf_elmt.readScalarByte()
+      when "string"
+        @netcdf_elmt.readScalarString()
+      else
+        raise "Unknown type: #{type}"
+      end
+
+    end
+
+    #------------------------------------------------------------------------------------
+    # Set the data cache
+    #------------------------------------------------------------------------------------
+
+    def set_cached_data(array, metadata = nil)
+      @netcdf_elmt.setCachedData(array.nc_array, metadata)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def caching=(boolean)
+      @netcdf_elmt.setCaching(boolean)
+    end
+
+    #------------------------------------------------------------------------------------
+    # Create a new Variable that is a logical subsection of this Variable.  The
+    # subsection can be specified passing the following arguments:
+    # shape
+    # origin
+    # size
+    # stride
+    # range
+    # section
+    # spec
+    #------------------------------------------------------------------------------------
+
+    def section(*args)
+
+      sec = MDArray::Section.build(*args)
+      NetCDF::Variable.new(@netcdf_elmt.section(sec.netcdf_elmt))
+      
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def set_cached_data(array, metadata)
+      @netcdf_elmt.setCachedData(array.nc_array, metadata)
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Prints the content of the current data slice
+    #------------------------------------------------------------------------------------
+    
+    def to_string
+      @netcdf_elmt.toString()
+    end
+
+    alias :to_s :to_string
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def to_string_debug
+      @netcdf_elmt.toSringDebug()
+    end
+
+    #------------------------------------------------------------------------------------
+    # Prints the content of the current data slice
+    #------------------------------------------------------------------------------------
+
+    def print
+      p to_string
+    end
+
+  end # Variable
+
+  #=======================================================================================
+  #
+  #=======================================================================================
+
+  class VariableWriter < Variable
+
+    #------------------------------------------------------------------------------------
+    # Remove an Attribute : uses the attribute hashCode to find it.
+    #------------------------------------------------------------------------------------
+
+    def remove_attribute(attribute, ignore_case = false)
+
+      if (attribute.is_a? String)
+        if (ignore_case)
+          @netcdf_elmt.removeAttributeIgnoreCase(attribute)
+        else
+          @netcdf_elmt.removeAttribute(attribute)
+        end
+      elsif (attribute.is_a? NetCDF::Attribute)
+        @netcdf_elmt.remove(attribute.netcdf_elmt)
+      else
+        raise "Given parameter is not an attribute: #{attribute}"
+      end
+
+    end
+
+    #------------------------------------------------------------------------------------
+    # Reset the dimension array.
+    #------------------------------------------------------------------------------------
+    
+    def reset_dimensions
+      @netcdf_elmt.resetDimensions()
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Use when dimensions have changed, to recalculate the shape.
+    #------------------------------------------------------------------------------------
+    
+    def reset_shape
+      @netcdf_elmt.resetShape()
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+  end # VariableWriter
+
+
+  #=======================================================================================
+  #
+  #=======================================================================================
+
+  class TimeVariable < Variable
+    include_package "ucar.nc2.time"
+
+    attr_reader :calendar
+    attr_reader :units
+    attr_reader :base_date
+
+    #------------------------------------------------------------------------------------
+    # Initializes the Variable by giving a java netcdf_variable
+    #------------------------------------------------------------------------------------
+
+    def initialize(netcdf_variable)
+
+      super(netcdf_variable)
+      @calendar = @netcdf_elmt.findAttribute("calendar").getStringValue()
+      @units = @netcdf_elmt.findAttribute("units").getStringValue()
+      date_unit = CalendarDateUnit.of(@calendar, @units)
+      @base_date = date_unit.getBaseCalendarDate()
+
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Returns the number of milliseconds elapsed from the base_date to the given date.
+    # The given date should be in iso_format.
+    #------------------------------------------------------------------------------------
+
+    def to_msec(iso_date)
+
+      date = CalendarDate.parseISOformat(@calendar, iso_date)
+      date.getDifferenceInMsecs(@base_date)
+
+    end
+
+    #------------------------------------------------------------------------------------
+    # 
+    #------------------------------------------------------------------------------------
+
+    def next
+
+      millisec_date = super
+      @base_date.add(millisec_date, CalendarPeriod.fromUnitString("Millisec")).toString()
+
+    end
+
+  end # TimeVariable
+
+
+end # NetCDFInterface