cdo 1.0.10 → 1.1.0

data/gemspec

@@ -3,7 +3,7 @@ $:.unshift File.join(File.dirname(__FILE__),"..","lib")
 
 spec = Gem::Specification.new do |s|
   s.name              = "cdo"
-  s.version           = '1.0.10'
+  s.version           = '1.1.0'
   s.platform          = Gem::Platform::RUBY
   s.files             = ["lib/cdo.rb"] + ["gemspec","COPYING","README.rdoc","ChangeLog"]
   s.test_file         = "test/test_cdo.rb"

data/lib/cdo.rb

@@ -16,12 +16,13 @@ require 'pp'
 # CDO calling mechnism
 module Cdo
 
-  VERSION = "1.0.10"
+  VERSION = "1.1.0"
 
   State = {
     :debug       => false,
-    :returnArray => false,
-    :operators   => []
+    :returnCdf => false,
+    :operators   => [],
+    :forceOutput => true
   }
   State[:debug] = true unless ENV['DEBUG'].nil?
 
@@ -51,7 +52,7 @@ module Cdo
     tstepcount vardes vardup varmul varquot2test varrms vertwind write_e5ml
     writegrid writerandom yearcount]
 
-  @@outputOperatorsPattern = /(diff|info|output|griddes|zaxisdes|show)/
+  @@outputOperatorsPattern = /(diff|info|output|griddes|zaxisdes|show|ncode|ndate|nlevel|nmon|nvar|nyear|ntime|npar|gradsdes|pardes)/
 
   private
   def Cdo.getOperators(force=false)
@@ -84,38 +85,50 @@ module Cdo
       system(cmd + ' 1>/dev/null 2>&1 ')
     end
   end
-  def Cdo.run(cmd,ofile='',options='',returnArray=false)
+  def Cdo.run(cmd,ofile='',options='',returnCdf=false,force=nil,returnArray=nil)
     cmd = "#{@@CDO} -O #{options} #{cmd} "
     case ofile
     when $stdout
       cmd << " 2>/dev/null"
+      puts cmd if Cdo.debug
       return IO.popen(cmd).readlines.map {|l| l.chomp.strip}
-    when nil
-      ofile = MyTempfile.path
+    else
+      force = State[:forceOutput] if force.nil?
+      if force or not File.exists?(ofile.to_s)
+        ofile = MyTempfile.path if ofile.nil?
+        cmd << "#{ofile}"
+        call(cmd)
+      else
+        warn "Use existing file '#{ofile}'" if Cdo.debug
+      end
     end
-    cmd << "#{ofile}"
-    call(cmd)
-    if returnArray or State[:returnArray]
+    if returnCdf or State[:returnCdf]
       Cdo.readCdf(ofile)
     else
       return ofile
     end
   end
+  def Cdo.parseArgs(args)
+    # splitinto hash-like args and the rest
+    operatorArgs = args.reject {|a| a.class == Hash}
+    opts = operatorArgs.empty? ? '' : ',' + operatorArgs.join(',')
+    io   = args.find {|a| a.class == Hash}
+    io   = {} if io.nil?
+    args.delete_if   {|a| a.class == Hash}
+    return [io,opts]
+  end
   def Cdo.method_missing(sym, *args, &block)
-    # args is expected to look like [opt1,...,optN,:in => iStream,:out => oStream] where
+    ## args is expected to look like [opt1,...,optN,:in => iStream,:out => oStream] where
     # iStream could be another CDO call (timmax(selname(Temp,U,V,ifile.nc))
     puts "Operator #{sym.to_s} is called" if State[:debug]
     if getOperators.include?(sym.to_s)
-      operatorArgs = args.reject {|a| a.class == Hash}
-      opts = operatorArgs.empty? ? '' : ',' + operatorArgs.join(',')
-      io   = args.find {|a| a.class == Hash}
-      io   = {} if io.nil?
-      args.delete_if   {|a| a.class == Hash}
+      io,opts = Cdo.parseArgs(args)
       if @@outputOperatorsPattern.match(sym)
         run(" -#{sym.to_s}#{opts} #{io[:in]} ",$stdout)
       else
-        opts = args.empty? ? '' : ',' + args.reject {|a| a.class == Hash}.join(',')
-        run(" -#{sym.to_s}#{opts} #{io[:in]} ",io[:out],io[:options],io[:returnArray])
+        #if opts[:force] or not File.exist?(opts[:out]) then
+          run(" -#{sym.to_s}#{opts} #{io[:in]} ",io[:out],io[:options],io[:returnCdf],io[:force])
+        #end
       end
     else
       warn "Operator #{sym.to_s} not found"
@@ -138,6 +151,12 @@ module Cdo
   def Cdo.debug
     State[:debug]
   end
+  def Cdo.forceOutput=(value)
+    State[:forceOutput] = value
+  end
+  def Cdo.forceOutput
+    State[:forceOutput]
+  end
   def Cdo.version
     cmd     = @@CDO + ' 2>&1'
     help    = IO.popen(cmd).readlines.map {|l| l.chomp.lstrip}
@@ -145,17 +164,17 @@ module Cdo
     line    = help.find {|v| v =~ regexp}
     version = regexp.match(line)[1]
   end
-  def Cdo.setReturnArray(value=true)
+  def Cdo.setReturnCdf(value=true)
     if value
       Cdo.loadCdf
     end
-    State[:returnArray] = value
+    State[:returnCdf] = value
   end
-  def Cdo.unsetReturnArray
-    setReturnArray(false)
+  def Cdo.unsetReturnCdf
+    setReturnCdf(false)
   end
-  def Cdo.returnArray
-    State[:returnArray]
+  def Cdo.returnCdf
+    State[:returnCdf]
   end
 
   def Cdo.hasCdo?(bin=@@CDO)
@@ -213,9 +232,16 @@ module Cdo
   end
 
   def Cdo.readCdf(iFile)
-    Cdo.loadCdf unless State[:returnArray] 
+    Cdo.loadCdf unless State[:returnCdf] 
     NetCDF.open(iFile)
   end
+
+  def Cdo.selindexlist(args)
+    
+  end
+
+  def Cdo.plot(args)
+  end
 end
 
 # Helper module for easy temp file handling

data/test/test_cdo.rb

@@ -35,6 +35,7 @@ class TestCdo < Test::Unit::TestCase
   end
 
   def test_outputOperators
+    Cdo.debug = true
     levels = Cdo.showlevel(:in => "-stdatm,0")
     assert_equal([0,0].map(&:to_s),levels)
 
@@ -66,9 +67,8 @@ class TestCdo < Test::Unit::TestCase
     (1...info.size).each {|i| assert_equal(0.0,info[i].split[-1].to_f)}
   end
   def test_operator_options
-    ofile = MyTempfile.path
     targetLevels = [0,10,50,100,200,400,1000]
-    Cdo.stdatm(targetLevels,:out => ofile)
+    ofile = Cdo.stdatm(targetLevels)
     levels = Cdo.showlevel(:in => ofile)
     [0,1].each {|i| assert_equal(targetLevels.map(&:to_s),levels[i].split)}
   end
@@ -82,17 +82,17 @@ class TestCdo < Test::Unit::TestCase
   end
   def test_chain
     ofile     = MyTempfile.path
-    #Cdo.Debug = true
+    Cdo.Debug = true
     Cdo.setname('veloc',:in => " -copy -random,r1x1",:out => ofile,:options => "-f nc")
     assert_equal(["veloc"],Cdo.showname(:in => ofile))
   end
 
   def test_diff
     diffv = Cdo.diffn(:in => "-random,r1x1 -random,r1x1")
-    assert_equal(diffv[1].split(' ')[4],"random")
-    assert_equal(diffv[1].split(' ')[-1],"0.53060")
+    assert_equal(diffv[1].split(' ')[-1],"random")
+    assert_equal(diffv[1].split(' ')[-3],"0.53060")
     diff  = Cdo.diff(:in => "-random,r1x1 -random,r1x1")
-    assert_equal(diff[1].split(' ')[-1],"0.53060")
+    assert_equal(diff[1].split(' ')[-3],"0.53060")
   end
 
   def test_operators
@@ -113,12 +113,12 @@ class TestCdo < Test::Unit::TestCase
     ofile0, ofile1 = MyTempfile.path, MyTempfile.path
     Cdo.fldsum(:in => Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc"),:out => ofile0)
     Cdo.fldsum(:in => "-stdatm,25,100,250,500,875,1400,2100,3000,4000,5000",:options => "-f nc",:out => ofile1)
-    Cdo.setReturnArray
+    Cdo.setReturnCdf
     MyTempfile.showFiles
     diff = Cdo.sub(:in => [ofile0,ofile1].join(' ')).var('T').get
     assert_equal(0.0,diff.min)
     assert_equal(0.0,diff.max)
-    Cdo.setReturnArray(false)
+    Cdo.setReturnCdf(false)
   end
 
   def test_tempfile
@@ -131,27 +131,67 @@ class TestCdo < Test::Unit::TestCase
     assert(File.exist?(ofile0))
   end
 
-  def test_returnArray
+  def test_returnCdf
     ofile = MyTempfile.path
-    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:out => ofile,:options => "-f nc")
+    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:out => ofile,:options => "-f nc",:force => true)
     assert_equal(ofile,vals)
-    Cdo.setReturnArray
+    Cdo.setReturnCdf
     vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:out => ofile,:options => "-f nc")
     assert_equal(["lon","lat","level","P","T"],vals.var_names)
     assert_equal(276,vals.var("T").get.flatten.mean.floor)
-    Cdo.unsetReturnArray
+    Cdo.unsetReturnCdf
     vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:out => ofile,:options => "-f nc")
     assert_equal(ofile,vals)
   end
-  def test_simple_returnArray
+  def test_simple_returnCdf
     ofile0, ofile1 = MyTempfile.path, MyTempfile.path
     sum = Cdo.fldsum(:in => Cdo.stdatm(0,:options => "-f nc"),
-               :returnArray => true).var("P").get
+               :returnCdf => true).var("P").get
     assert_equal(1013.25,sum.min)
     sum = Cdo.fldsum(:in => Cdo.stdatm(0,:options => "-f nc"),:out => ofile0)
     assert_equal(ofile0,sum)
-    test_returnArray
+    test_returnCdf
+  end
+  def test_force
+    outs = []
+    # tempfiles
+    outs << Cdo.stdatm(0,10,20)
+    outs << Cdo.stdatm(0,10,20)
+    assert_not_equal(outs[0],outs[1])
 
+    # deticated output, force = true
+    outs.clear
+    outs << Cdo.stdatm(0,10,20,:out => 'test_force')
+    mtime0 = File.stat(outs[-1]).mtime
+    outs << Cdo.stdatm(0,10,20,:out => 'test_force')
+    mtime1 = File.stat(outs[-1]).mtime
+    assert_not_equal(mtime0,mtime1)
+    assert_equal(outs[0],outs[1])
+    FileUtils.rm('test_force')
+    outs.clear
+
+    # dedicated output, force = false
+    ofile = 'test_force_false'
+    outs << Cdo.stdatm(0,10,20,:out => ofile,:force => false)
+    mtime0 = File.stat(outs[-1]).mtime
+    outs << Cdo.stdatm(0,10,20,:out => ofile,:force => false)
+    mtime1 = File.stat(outs[-1]).mtime
+    assert_equal(mtime0,mtime1)
+    assert_equal(outs[0],outs[1])
+    FileUtils.rm(ofile)
+    outs.clear
+
+    # dedicated output, global force setting
+    ofile = 'test_force_global'
+    Cdo.forceOutput = false
+    outs << Cdo.stdatm(0,10,20,:out => ofile)
+    mtime0 = File.stat(outs[-1]).mtime
+    outs << Cdo.stdatm(0,10,20,:out => ofile)
+    mtime1 = File.stat(outs[-1]).mtime
+    assert_equal(mtime0,mtime1)
+    assert_equal(outs[0],outs[1])
+    FileUtils.rm(ofile)
+    outs.clear
   end
 
   def test_thickness
@@ -167,11 +207,22 @@ class TestCdo < Test::Unit::TestCase
   end
 
   def test_verticalLevels
+    Cdo.debug = true
     targetThicknesses = [50.0,  100.0,  200.0,  300.0,  450.0,  600.0,  800.0, 1000.0, 1000.0, 1000.0]
     sourceLevels = %W{25 100 250 500 875 1400 2100 3000 4000 5000}
     thicknesses = Cdo.thicknessOfLevels(:in => "-selname,T #{Cdo.stdatm(*sourceLevels,:options => '-f nc')}")
     assert_equal(targetThicknesses,thicknesses)
   end
+
+  def test_parseArgs
+    io,opts = Cdo.parseArgs([1,2,3,:in => '1',:out => '2',:force => true,:returnCdf => "T"])
+    assert_equal("1",io[:in])
+    assert_equal("2",io[:out])
+    assert_equal(true,io[:force])
+    assert_equal("T",io[:returnCdf])
+    pp [io,opts]
+  end 
+
   if 'thingol' == `hostname`.chomp  then
     def test_readCdf
       input = "-settunits,days  -setyear,2000 -for,1,4"
@@ -179,13 +230,8 @@ class TestCdo < Test::Unit::TestCase
       cdf     = Cdo.readCdf(cdfFile)
       assert_equal(['lon','lat','time','for'],cdf.var_names)
     end
-    def test_tmp
-      tempfilesStart = Dir.glob('/tmp/Module*').sort
-      tempfilesEnd   = Dir.glob('/tmp/Module*').sort
-      assert_equal(tempfilesStart,tempfilesEnd)
-      test_combine()
-      tempfilesEnd = Dir.glob('/tmp/Module**')
-      assert_empty(tempfilesStart-tempfilesEnd)
+    def test_selIndexListFromIcon
+      input = "~/data/icon/oce.nc"
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cdo
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-03 00:00:00.000000000 Z
+date: 2012-11-15 00:00:00.000000000 Z
 dependencies: []
 description: Easy access to the Climate Data operators
 email: stark.dreamdetective@gmail.com
@@ -46,7 +46,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Easy access to the Climate Data operators