cdo 1.3.6 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae07b4039ff9ecbaea1bdea8a4d50c83b63bdd5d65c6b87f5d0c8f67632dc937
-  data.tar.gz: 23d76998b8cd25d1b0ba6619651c255c33920e104181912ccdbe588bfb580e08
+  metadata.gz: 2085dbda68e564e4449b83e69c840dcfc817b60adfe2010c597eeb795eade50d
+  data.tar.gz: 34c2082c1ed7de54cb889dde3cd8fe3d3e8e9ba7abd6f20f655bd6d5478e0905
 SHA512:
-  metadata.gz: d870e95cb67677c2f00aa707ce458ee314c7767c857c9085c65a7e838eba6b5e00e40c2c529b1c603b9444562de3e85f2cae812386516261460ff842660aa50e
-  data.tar.gz: 70d7277e46d3c12175fe9168a86aa60e60f0d8837a3d36a94906ce9c3ac725d7c2f8428fc8e841f8d5fbba1c92f7fd4f5bf2e2ba6bbbcda6935815507ac21f42
+  metadata.gz: 38f8689cf9674697d64c9958df35c85177e86c08d6becaa808cc13a56c460fcbce6a6f57c43ca376c129c531c26a1b09dbae38a07c1557e36ec1746f4365ca50
+  data.tar.gz: 71d527c68c39531e5b3c8007a05fa0b46989efa4b49da2a4e3738ced45d60137d32071bfe77a2da11273a6a716f0c9e17484a4676680825f480633289521f921

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.3.6'
+  s.version           = '1.4.0'
   s.platform          = Gem::Platform::RUBY
   s.files             = ["lib/cdo.rb","gemspec","LICENSE"]
   s.test_file         = "test/test_cdo.rb"

data/lib/cdo.rb

@@ -2,6 +2,8 @@ require 'pp'
 require 'open3'
 require 'logger'
 require 'stringio'
+require 'json'
+require 'tempfile'
 
 class Hash
   alias :include? :has_key?
@@ -12,17 +14,25 @@ class Cdo
 
   # hardcoded fallback list of output operators - from 1.8.0 there is an
   # options for this: --operators_no_output
-  NoOutputOperators = %w[cdiread cmor codetab conv_cmor_table diff diffc diffn diffp
-  diffv dump_cmor_table dumpmap filedes ggstat ggstats gmtcells gmtxyz gradsdes
-  griddes griddes2 gridverify info infoc infon infop infos infov map ncode
-  ncode ndate ngridpoints ngrids nlevel nmon npar ntime nvar nyear output
-  outputarr outputbounds outputboundscpt outputcenter outputcenter2
-  outputcentercpt outputext outputf outputfld outputint outputkey outputsrv
-  outputtab outputtri outputts outputvector outputvrml outputxyz pardes partab
-  partab2 seinfo seinfoc seinfon seinfop showcode showdate showformat showlevel
-  showltype showmon showname showparam showstdname showtime showtimestamp
-  showunit showvar showyear sinfo sinfoc sinfon sinfop sinfov
-  spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
+  # this list works for cdo-1.6.4
+  NoOutputOperators = %w[cdiread cmor codetab conv_cmor_table diff diffc diffn
+  diffp diffv dump_cmor_table dumpmap filedes gmtcells gmtxyz gradsdes griddes
+  griddes2 gridverify info infoc infon infop infos infov map ncode ndate
+  ngridpoints ngrids nlevel nmon npar ntime nvar nyear output outputarr
+  outputbounds outputboundscpt outputcenter outputcenter2 outputcentercpt
+  outputext outputf outputfld outputint outputkey outputsrv outputtab outputtri
+  outputts outputvector outputvrml outputxyz pardes partab partab2 seinfo
+  seinfoc seinfon seinfop showattribute showatts showattsglob showattsvar
+  showcode showdate showformat showgrid showlevel showltype showmon showname
+  showparam showstdname showtime showtimestamp showunit showvar showyear sinfo
+  sinfoc sinfon sinfop sinfov spartab specinfo tinfo vardes vct vct2 verifygrid
+  vlist xinfon zaxisdes]
+  TwoOutputOperators = %w[trend samplegridicon mrotuv eoftime
+  eofspatial eof3dtime eof3dspatial eof3d eof complextorect complextopol]
+  MoreOutputOperators = %w[distgrid eofcoeff eofcoeff3d intyear scatter splitcode
+  splitday splitgrid splithour splitlevel splitmon splitname splitparam splitrec
+  splitseas splitsel splittabnum splitvar splityear splityearmon splitzaxis]
+
 
   attr_accessor :cdo, :returnCdf, :forceOutput, :env, :debug, :logging, :logFile
   attr_reader   :operators, :filetypes
@@ -32,6 +42,7 @@ class Cdo
                  returnFalseOnError: false,
                  forceOutput: true,
                  env: {},
+                 tempdir: Dir.tmpdir,
                  logging: false,
                  logFile: StringIO.new,
                  debug: false,
@@ -41,20 +52,30 @@ class Cdo
     @cdo = ENV.has_key?('CDO') ? ENV['CDO'] : cdo
 
     @operators              = getOperators(@cdo)
+    @noOutputOperators      = @operators.select {|op,io| 0 == io}.keys
+
     @returnCdf              = returnCdf
     @forceOutput            = forceOutput
     @env                    = env
     @debug                  = ENV.has_key?('DEBUG') ? true : debug
-    @noOutputOperators      = getNoOuputOperators(@cdo) # operators without output files (write to stdout)
     @returnNilOnError       = returnNilOnError
 
-    @filetypes              = getFiletypes
     @returnFalseOnError     = returnFalseOnError
 
+    @tempStore              = CdoTempfileStore.new(tempdir)
     @logging                = logging
     @logFile                = logFile
     @logger                 = Logger.new(@logFile,'a')
     @logger.level           = Logger::INFO
+
+    @config                 = getFeatures
+
+    # create methods to descibe what can be done with the binary
+    @config.each {|k,v|
+      self.class.send :define_method, k.tr('-','_') do
+        v
+      end
+    }
   end
 
   private # {{{
@@ -73,9 +94,13 @@ class Cdo
   end
 
   # collect the complete list of possible operators
-  def getOperators(path2cdo)
+  def getOperators(path2cdo) #{{{
+    operators = {}
+
+    # little side note: the option --operators_no_output works in 1.8.0 and
+    # 1.8.2, but not in 1.9.0, from 1.9.1 it works again
     case
-    when version <= '1.7.0' then
+    when version < '1.7.2' then
       cmd       = path2cdo + ' 2>&1'
       help      = IO.popen(cmd).readlines.map {|l| l.chomp.lstrip}
       if 5 >= help.size
@@ -84,38 +109,77 @@ class Cdo
         exit
       end
 
-      operators = help[(help.index("Operators:")+1)..help.index(help.find {|v| v =~ /CDO version/ }) - 2].join(' ').split
-    when version <= '1.9.1' then
-      cmd       = "#{path2cdo} --operators"
-      operators = IO.popen(cmd).readlines.map {|l| l.split(' ').first }
+      _operators = help[(help.index("Operators:")+1)..help.index(help.find {|v|
+        v =~ /CDO version/
+      }) - 2].join(' ').split
+
+      # build up operator inventory
+      # default is 1 output stream
+      _operators.each {|op| operators[op] = 1 }
+      operators.each {|op,_|
+        operators[op] = 0  if NoOutputOperators.include?(op)
+        operators[op] = 2  if TwoOutputOperators.include?(op)
+        operators[op] = -1 if MoreOutputOperators.include?(op)
+      }
+
+    when (version < '1.8.0'  or '1.9.0' == version) then
+      cmd                = "#{path2cdo} --operators"
+      _operators         = IO.popen(cmd).readlines.map {|l| l.split(' ').first }
+
+      _operators.each {|op| operators[op] = 1 }
+      operators.each {|op,_|
+        operators[op] = 0  if NoOutputOperators.include?(op)
+        operators[op] = 2  if TwoOutputOperators.include?(op)
+        operators[op] = -1 if MoreOutputOperators.include?(op)
+      }
+
+
+    when version < '1.9.3' then
+
+      cmd                = "#{path2cdo} --operators"
+      _operators         = IO.popen(cmd).readlines.map {|l| l.split(' ').first }
+      cmd                = "#{path2cdo} --operators_no_output"
+      _operatorsNoOutput = IO.popen(cmd).readlines.map {|l| l.split(' ').first }
+
+      # build up operator inventory
+      _operators.each {|op| operators[op] = 1 }
+      _operatorsNoOutput.each {|op| operators[op] = 0}
+      operators.each {|op,_|
+        operators[op] = 0  if _operatorsNoOutput.include?(op)
+        operators[op] = 2  if TwoOutputOperators.include?(op)
+        operators[op] = -1 if MoreOutputOperators.include?(op)
+      }
+
     else
       cmd       = "#{path2cdo} --operators"
       operators = {}
       IO.popen(cmd).readlines.map {|line|
-        lineContent = line.chomp.split(' ')
-        name = lineContent[0]
-        iCounter, oCounter = lineContent[-1].tr(')','').tr('(','').split('|')
-        operators[name] = { iStreams: iCounter.to_i, oStreams: oCounter.to_i }
+        lineContent        = line.chomp.split(' ')
+        name               = lineContent[0]
+        iCounter, oCounter = lineContent[-1][1..-1].split('|')
+        operators[name]    = oCounter.to_i
       }
     end
     return operators
-  end
+  end #}}}
 
-  def getNoOuputOperators(path2cdo)
-    if version > '1.8.0' and version < '1.9.0' then
-      puts 'CMD:'+path2cdo+' --operators_no_output' if @debug
-      IO.popen(path2cdo+' --operators_no_output').readlines.map{|line| line.split(' ')[0]}.flatten
-    else
-      NoOutputOperators
-    end
-  end
+  # get meta-data about the CDO installation
+  def getFeatures
+    config = {}
+    config.default(false)
 
-  # get supported IO filetypes form the binary
-  def getFiletypes
-    _, _, stderr, _ = Open3.popen3(@cdo + " -V")
-    supported       = stderr.readlines.map(&:chomp)
+    if version > '1.9.3' then
+      config.merge!(JSON.parse(IO.popen(@cdo + " --config all").read.chomp))
+      config.each {|k,v| config[k] = ('yes' == v) ? true : false}
+    else
+      _, _, stderr, _ = Open3.popen3(@cdo + " -V")
+      supported       = stderr.readlines.map(&:chomp)
 
-    supported.grep(/(Filetypes)/)[0].split(':')[1].split.map(&:downcase)
+      supported.grep(/(Filetypes)/)[0].split(':')[1].split.map(&:downcase).each {|ftype|
+        config["has-#{ftype}"] = true
+      }
+    end
+    config
   end
 
   # Execute the given cdo call and return all outputs
@@ -174,18 +238,25 @@ class Cdo
            autoSplit:     nil)
     options = options.to_s
 
-    options << '-f nc' if options.empty? and ( \
-                                              (     returnCdf ) or \
-                                              ( not returnArray.nil? ) or \
-                                              ( not returnMaArray.nil?) \
-                                             )
-    #
+    # switch netcdf output if data of filehandles are requested as output
+    options << ' -f nc' if ( \
+                             (     returnCdf ) or \
+                             ( not returnArray.nil? ) or \
+                             ( not returnMaArray.nil?) \
+                           )
+
     # setup basic operator execution command
     cmd = "#{@cdo} -O #{options} -#{operatorName}#{operatorParameters} #{input} "
 
     # use an empty hash for non-given environment
     env = {} if env.nil?
 
+    # list of all output streams
+    outputs = []
+
+    # just collect given output(s)
+    outputs << output unless output.nil?
+
     case output
     when $stdout
       retvals = _call(cmd,env)
@@ -204,13 +275,18 @@ class Cdo
         end
       end
     else
+      # if operators was not called with output-forcing given, take the global switch
       force = @forceOutput if force.nil?
+
       if force or not File.exists?(output.to_s)
-        # create a tempfile if output is not given
-        output = MyTempfile.path if output.nil?
+        # create tempfile(s) according to the number of output streams needed
+        # if output argument is missing
+        if output.nil? then
+          operators[operatorName].times { outputs << @tempStore.newFile}
+        end
 
         #finalize the execution command
-        cmd << "#{output}"
+        cmd << "#{outputs.join(' ')}"
 
         retvals = _call(cmd,env)
 
@@ -222,20 +298,25 @@ class Cdo
           end
         end
       else
-        warn "Use existing file '#{output}'" if @debug
+        warn "Use existing file(s) '#{outputs.join(' ')}'" if @debug
       end
     end
 
+    # return data arrays instead - this is for now limitted to fields of the
+    # first output file. number from the second need only one addition line, so
+    # I think this is sufficient
     if not returnArray.nil?
-      readArray(output,returnArray)
+      readArray(outputs[0],returnArray)
     elsif not returnMaArray.nil?
-      readMaArray(output,returnMaArray)
+      readMaArray(outputs[0],returnMaArray)
     elsif returnCdf or @returnCdf
-      readCdf(output)
+      retval = outputs.map{|f| readCdf(f)}
+      return 1 == retval.size ? retval[0] : retval
     elsif /^split/.match(operatorName)
       Dir.glob("#{output}*")
     else
-      output
+      return outputs[0] if outputs.size == 1
+      return outputs
     end
   end
 
@@ -295,17 +376,20 @@ class Cdo
       return File.open(@logFile).readlines
     end
   end
+
   # print the loggin messaged
   def showLog
     puts collectLogs
   end
 
+  # check if the CDO binary is present and works
   def hasCdo(path=@cdo)
     executable = system("#{path} -V >/dev/null 2>&1")
     fullpath   = File.exists?(path) and File.executable?(path)
 
     return (executable or fullpath)
   end
+
   # check if cdo backend is working
   def check
     return false unless hasCdo
@@ -316,6 +400,7 @@ class Cdo
     return true
   end
 
+  # return CDO version string
   def version(verbose=false)
     info = IO.popen("#{@cdo} -V 2>&1").readlines
     if verbose then
@@ -359,8 +444,9 @@ class Cdo
     end
   end
 
-  def noOutputOps
-    getNoOuputOperators(@cdo)
+  # remove tempfiles created from this or previous runs
+  def cleanTempDir
+    @tempStore.cleanTempDir
   end
   # }}}
 
@@ -392,33 +478,50 @@ class Cdo
 
 end
 #
-# Helper module for easy temp file handling
-module MyTempfile
-  require 'tempfile'
-  @@_tempfiles           = []
-  @@persistent_tempfiles = false
-  @@N                    = 10000000
-
-  def MyTempfile.setPersist(value)
-    @@persistent_tempfiles = value
+# Helper module for easy temp file handling {{{
+class CdoTempfileStore
+  # base for persitent temp files - just for debugging
+  N = 10000000
+
+  def initialize(dir=Dir.tmpdir)
+    @dir                  = dir
+    @tag                  = 'Cdorb'
+    @persistent_tempfiles = false
+
+    # storage for filenames in order to prevent too early removement
+    @_tempfiles           = []
+
+    # make sure the tempdir ie really there
+    Dir.mkdir(@dir) unless Dir.exists?(@dir)
   end
 
-  def MyTempfile.path
-    unless @@persistent_tempfiles
-      t = Tempfile.new(self.class.to_s)
-      @@_tempfiles << t
-      @@_tempfiles << t.path
+  def setPersist(value)
+    @persistent_tempfiles = value
+  end
+
+  def newFile
+    unless @persistent_tempfiles
+      t = Tempfile.new(@tag,@dir)
+      @_tempfiles << t
+      @_tempfiles << t.path
       t.path
     else
-      t = "_"+rand(@@N).to_s
-      @@_tempfiles << t
+      t = "_"+rand(N).to_s
+      @_tempfiles << t
       t
     end
   end
 
-  def MyTempfile.showFiles
-    @@_tempfiles.each {|f| print(f+" ") if f.kind_of? String}
+  def showFiles
+    @_tempfiles.each {|f| print(f+" ") if f.kind_of? String}
   end
-end
 
-#vim:fdm=marker
+  def cleanTempDir
+    # filter by name, realfile and ownership
+    Dir.entries(@dir).map {|f| "#@dir/#{f}"}.find_all {|file|
+      File.file?(file) and File.owned?(file) and file.include?(@tag)
+    }.each {|f| File.unlink(f)}
+  end
+end #}}}
+
+# vim: fdm=marker

data/test/test_cdo.rb

@@ -18,6 +18,7 @@ class TestCdo < Minitest::Test
 
   def setup
     @cdo = Cdo.new
+    @tempStore = CdoTempfileStore.new
   end
 
   def test_cdo
@@ -82,7 +83,7 @@ class TestCdo < Minitest::Test
   end
   def test_CDO_version
     assert("1.4.3.1" < @cdo.version,"Version too low: #{@cdo.version}")
-    assert("1.7.1" < @cdo.version,"Version too low: #{@cdo.version}")
+    assert("1.6.3" < @cdo.version,"Version too low: #{@cdo.version}")
     assert("3.0" > @cdo.version,"Version too high: #{@cdo.version}")
   end
   def test_args
@@ -264,23 +265,25 @@ class TestCdo < Minitest::Test
     assert_nil(@cdo.diffv(:input => ["-stdatm,0",fileB]).last)
   end
 
-  def test_filetypes
-    assert(@cdo.filetypes.find{|ft| /^grb/.match(ft)},"GRIB support missing")
-    assert(@cdo.filetypes.include?("nc4"),"NETCDF4 support missing")
-    assert(@cdo.filetypes.include?("ext"),"EXTRA support missing")
-    assert_raises ArgumentError do
-      @cdo.filetypes("foo")
-    end
+  def test_features
+    assert_equal(true,@cdo.has_srv)
+    assert_equal(true,@cdo.has_ieg)
+    assert_equal(true,@cdo.has_ext)
   end
 
   def test_noOutputOps
-    %w[griddes griddes2 gridverify info infoc infon infop infos infov map ncode
-       ncode ndate ngridpoints ngrids nlevel nmon npar ntime nvar nyear output
+    operators = @cdo.operators
+    %w[griddes griddes2 gridverify info infoc infon infop infos infov map
        outputarr outputbounds outputboundscpt outputcenter outputcenter2
        outputcentercpt outputext outputf outputfld outputint outputkey outputsrv
        outputtab outputtri outputts outputvector outputvrml outputxyz pardes partab].each {|op|
-      assert(@cdo.noOutputOps.include?(op))
+      assert(operators.include?(op),"Operator '#{op}' cannot be found!")
+      assert_equal(0,operators[op],"Operator '#{op}' has a non-zero output counter!")
     }
+    # just a rought estimation
+    opsCounf = @cdo.operators.select {|_,c| 0 == c}.size
+    assert(opsCounf > 50)
+    assert(opsCounf < 200)
   end
 
   def test_output_set_to_nil
@@ -311,59 +314,226 @@ class TestCdo < Minitest::Test
     }
   end
 
+  def test_operators_with_multiple_output_files
+    assert_equal(1,@cdo.operators['topo'],'wrong output counter for "topo"')
+    assert_equal(0,@cdo.operators['sinfo'],'wrong output counter for "sinfo"')
+    assert_equal(0,@cdo.operators['ngridpoints'],'wrong output counter for "sinfo"') if @cdo.version > '1.6.4'
+
+    assert_equal(-1,@cdo.operators['splitsel'],'wrong output counter for "splitsel"')
+    assert_equal(2,@cdo.operators['trend'],'wrong output counter for "trend"')
+    # create input for eof
+    #
+    # check automatic generation ot two tempfiles
+    aFile, bFile = @cdo.trend(input: "-addc,7 -mulc,44 -for,1,100")
+    assert_equal(51.0,@cdo.outputkey('value',input: aFile)[-1].to_f)
+    assert_equal(44.0,@cdo.outputkey('value',input: bFile)[-1].to_f)
+    # check usage of 'returnCdf' with these operators
+    aFile, bFile = @cdo.trend(input: "-addc,7 -mulc,44 -for,1,100",returnCdf: true)
+    assert_equal(51.0, aFile.var('for').get.flatten[0],"got wrong value from cdf handle")
+    assert_equal(44.0, bFile.var('for').get.flatten[0],"got wrong value from cdf handle")
+
+    avar = @cdo.trend(input: "-addc,7 -mulc,44 -for,1,100",returnArray: 'for').flatten[0]
+    assert_equal(51.0, avar,"got wrong value from narray")
+  end
+  def test_tempdir
+    # manual set path
+    tag = 'tempRb'
+    tempPath = Dir.pwd+'/'+tag
+    pp Dir.glob("#{tempPath}/*").size
+    assert_equal(0,Dir.glob("#{tempPath}/*").size)
+    cdo = Cdo.new(tempdir: tempPath)
+    cdo.topo('r10x10',options: '-f nc')
+    assert_equal(1,Dir.glob("#{tempPath}/*").size)
+    cdo.topo('r10x10',options: '-f nc')
+    cdo.topo('r10x10',options: '-f nc')
+    assert_equal(3,Dir.glob("#{tempPath}/*").size)
+    cdo.topo('r10x10',options: '-f nc')
+    cdo.topo('r10x10',options: '-f nc')
+    assert_equal(5,Dir.glob("#{tempPath}/*").size)
+    cdo.cleanTempDir
+    assert_equal(0,Dir.glob("#{tempPath}/*").size)
+  end
+
+  def test_returnArray
+    temperature = @cdo.stdatm(0,:returnCdf => true).var('T').get.flatten[0]
+    assert(1.7 < temperature,"Temperature to low!")
+    assert_raises ArgumentError do
+      @cdo.stdatm(0,:returnArray => 'TT')
+    end
+    temperature = @cdo.stdatm(0,:returnArray => 'T')
+    assert_equal(288.0,temperature.flatten[0])
+    pressure = @cdo.stdatm(0,1000,:options => '-b F64',:returnArray => 'P')
+    assert_equal("1013.25 898.543456035875",pressure.flatten.to_a.join(' '))
+  end
+  def test_returnMaArray
+    @cdo.debug = @@debug
+    topo = @cdo.topo(:returnMaArray => 'topo')
+    assert_equal(-1890.0,topo.mean.round)
+    bathy = @cdo.setrtomiss(0,10000,
+        :input => @cdo.topo(:options => '-f nc'),:returnMaArray => 'topo')
+    assert_equal(-3386.0,bathy.mean.round)
+    oro = @cdo.setrtomiss(-10000,0,
+        :input => @cdo.topo(:options => '-f nc'),:returnMaArray => 'topo')
+    assert_equal(1142.0,oro.mean.round)
+    bathy = @cdo.remapnn('r2x2',:input => @cdo.topo(:options => '-f nc'), :returnMaArray => 'topo')
+    assert_equal(-4298.0,bathy[0,0])
+    assert_equal(-2669.0,bathy[1,0])
+    ta = @cdo.remapnn('r2x2',:input => @cdo.topo(:options => '-f nc'))
+    tb = @cdo.subc(-2669.0,:input => ta)
+    withMask = @cdo.div(:input => ta+" "+tb,:returnMaArray => 'topo')
+    assert(-8.0e+33 > withMask[1,0])
+    assert(0 < withMask[0,0])
+    assert(0 < withMask[0,1])
+    assert(0 < withMask[1,1])
+  end
+  def test_combine
+    ofile0, ofile1 = @tempStore.newFile, @tempStore.newFile
+    @cdo.fldsum(:input => @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc"),:output => ofile0)
+    @cdo.fldsum(:input => "-stdatm,25,100,250,500,875,1400,2100,3000,4000,5000",:options => "-f nc",:output => ofile1)
+    @cdo.returnCdf = true
+    @tempStore.showFiles
+    diff = @cdo.sub(:input => [ofile0,ofile1].join(' ')).var('T').get
+    assert_equal(0.0,diff.min)
+    assert_equal(0.0,diff.max)
+    @cdo.returnCdf = false
+  end
+
+  def test_returnCdf
+    ofile = rand(0xfffff).to_s + '_test_returnCdf.nc'
+    vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
+    assert_equal(ofile,vals)
+    @cdo.returnCdf = true
+    vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => 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.returnCdf = false
+    vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
+    assert_equal(ofile,vals)
+    FileUtils.rm(ofile)
+  end
+  def test_simple_returnCdf
+    ofile0, ofile1 = @tempStore.newFile, @tempStore.newFile
+    sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),
+                      :returnCdf => true).var("P").get
+    assert_equal(1013.25,sum.min)
+    sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),:output => ofile0)
+    assert_equal(ofile0,sum)
+    test_returnCdf
+  end
+  def test_readCdf
+    input = "-settunits,days  -setyear,2000 -for,1,4"
+    cdfFile = @cdo.copy(:options =>"-f nc",:input=>input)
+    cdf     = @cdo.readCdf(cdfFile)
+    assert_empty(['lon','lat','for','time'] - cdf.var_names)
+  end
+  def test_combine
+    ofile0, ofile1 = @tempStore.newFile, @tempStore.newFile
+    @cdo.fldsum(:input => @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc"),:output => ofile0)
+    @cdo.fldsum(:input => "-stdatm,25,100,250,500,875,1400,2100,3000,4000,5000",:options => "-f nc",:output => ofile1)
+    @cdo.returnCdf = true
+    @tempStore.showFiles
+    diff = @cdo.sub(:input => [ofile0,ofile1].join(' ')).var('T').get
+    assert_equal(0.0,diff.min)
+    assert_equal(0.0,diff.max)
+    @cdo.returnCdf = false
+  end
+  def test_readArray
+    @cdo.debug = @@debug
+    assert_equal([40,80],@cdo.readArray(@cdo.sellonlatbox(-10,10,-20,20,:input => '-topo',:options => '-f nc'), 'topo').shape)
+  end
+  def test_env
+    oTag     = 'test_env_with_splitlevel_'
+    levels   = [0,10,100]
+    expected = levels.map {|l| "test_env_with_splitlevel_000#{l.to_s.rjust(3,'0')}"}
+    # clean up first
+    rm(Dir.glob(oTag+'*'))
+
+    # oType = grb (default)
+    ofiles = expected.map {|f| f += '.grb'}
+    @cdo.splitlevel(input: "-stdatm,0,10,100",output: oTag)
+    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
+    rm(ofiles)
+
+    # oType = nc, from cdo options
+    ofiles = expected.map {|f| f += '.nc'}
+    @cdo.splitlevel(input: "-stdatm,0,10,100",output: oTag,options: '-f nc')
+    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
+    rm(ofiles)
+
+    # oType = nc, from input type
+    ofiles = expected.map {|f| f += '.nc'}
+    @cdo.splitlevel(input: @cdo.stdatm(0,10,100,options: '-f nc'),output: oTag)
+    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
+    rm(ofiles)
+
+    # oType = nc, from input ENV
+    ofiles = expected.map {|f| f += '.nc2'}
+    @cdo.env = {'CDO_FILE_SUFFIX' => '.nc2'}
+    @cdo.splitlevel(input: @cdo.stdatm(0,10,100,options: '-f nc'),output: oTag)
+    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
+    rm(ofiles)
+
+    # oType = nc, from input ENV setting for each call
+    ofiles = expected.map {|f| f += '.nc4'}
+    @cdo.splitlevel(input: @cdo.stdatm(0,10,100,options: '-f nc'),output: oTag,env: {'CDO_FILE_SUFFIX' => '.nc4'})
+    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
+    rm(ofiles)
+  end
+  def test_log
+    cmd = '-fldmean -mul -random,r20x20 -topo,r20x20'
+    #  logging without a real file
+    @cdo = Cdo.new(                    returnNilOnError: true)
+    @cdo.debug = false
+    @cdo.logging = true
+    @cdo.topo
+    @cdo.temp
+    @cdo.sinfov(input: cmd)
+    puts @cdo.showLog
+    @cdo.sinfov(input: '-top')
+    @cdo.topo
+    puts @cdo.showLog
+    #  use a use definded file for looging
+    @cdo = Cdo.new(logFile: 'test.log',logging: true, returnNilOnError: true)
+    @cdo.topo
+    @cdo.temp
+    @cdo.sinfov(input: cmd)
+    puts @cdo.showLog
+  end
   if @@maintainermode  then
     require 'unifiedPlot'
 
+    def test_system_tempdir
+      # automatic path
+      tempPath = Dir.tmpdir
+      tag = 'Cdorb'
+      pattern = "#{tempPath}/#{tag}*"
+      cdo = Cdo.new
+      assert_equal(0,Dir.glob(pattern).size)
+      cdo.topo('r10x10')
+      assert_equal(1,Dir.glob(pattern).size)
+      cdo.topo('r10x10')
+      cdo.topo('r10x10',options: '-f nc')
+      assert_equal(3,Dir.glob(pattern).size)
+      cdo.topo('r10x10',options: '-f nc')
+      cdo.topo('r10x10',options: '-f nc')
+      cdo.topo('r10x10',options: '-f nc')
+      cdo.topo('r10x10')
+      cdo.topo('r10x10',options: '-f nc')
+      cdo.topo('r10x10',options: '-f nc')
+      cdo.topo('r10x10',options: '-f nc')
+      cdo.topo('r10x10')
+      cdo.topo('r10x10',options: '-f nc')
+      assert_equal(12,Dir.glob(pattern).size)
+      cdo.cleanTempDir()
+      assert_equal(0,Dir.glob(pattern).size)
+    end
     def test_longChain
       ifile = "-enlarge,global_0.3 -settaxis,2000-01-01 -expr,'t=sin(for*3.141529/180.0)' -for,1,10"
       t = @cdo.fldmax(input: "-div -sub -timmean -seltimestep,2,3 #{ifile} -seltimestep,1 #{ifile}  -gridarea #{ifile}",returnArray: "t")
       assert_equal(8.981299259858133e-09,t[0])
     end
-    def test_returnArray
-      temperature = @cdo.stdatm(0,:options => '-f nc',:returnCdf => true).var('T').get.flatten[0]
-      assert_raises ArgumentError do
-        @cdo.stdatm(0,:options => '-f nc',:returnArray => 'TT')
-      end
-      temperature = @cdo.stdatm(0,:options => '-f nc',:returnArray => 'T')
-      assert_equal(288.0,temperature.flatten[0])
-      pressure = @cdo.stdatm(0,1000,:options => '-f nc -b F64',:returnArray => 'P')
-      assert_equal("1013.25 898.543456035875",pressure.flatten.to_a.join(' '))
-    end
-    def test_returnMaArray
-      @cdo.debug = @@debug
-      topo = @cdo.topo(:options => '-f nc',:returnMaArray => 'topo')
-      assert_equal(-1890.0,topo.mean.round)
-      bathy = @cdo.setrtomiss(0,10000,
-          :input => @cdo.topo(:options => '-f nc'),:returnMaArray => 'topo')
-      assert_equal(-3386.0,bathy.mean.round)
-      oro = @cdo.setrtomiss(-10000,0,
-          :input => @cdo.topo(:options => '-f nc'),:returnMaArray => 'topo')
-      assert_equal(1142.0,oro.mean.round)
-      bathy = @cdo.remapnn('r2x2',:input => @cdo.topo(:options => '-f nc'), :returnMaArray => 'topo')
-      assert_equal(-4298.0,bathy[0,0])
-      assert_equal(-2669.0,bathy[1,0])
-      ta = @cdo.remapnn('r2x2',:input => @cdo.topo(:options => '-f nc'))
-      tb = @cdo.subc(-2669.0,:input => ta)
-      withMask = @cdo.div(:input => ta+" "+tb,:returnMaArray => 'topo')
-      assert(-8.0e+33 > withMask[1,0])
-      assert(0 < withMask[0,0])
-      assert(0 < withMask[0,1])
-      assert(0 < withMask[1,1])
-    end
-    def test_combine
-      ofile0, ofile1 = MyTempfile.path, MyTempfile.path
-      @cdo.fldsum(:input => @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc"),:output => ofile0)
-      @cdo.fldsum(:input => "-stdatm,25,100,250,500,875,1400,2100,3000,4000,5000",:options => "-f nc",:output => ofile1)
-      @cdo.returnCdf = true
-      MyTempfile.showFiles
-      diff = @cdo.sub(:input => [ofile0,ofile1].join(' ')).var('T').get
-      assert_equal(0.0,diff.min)
-      assert_equal(0.0,diff.max)
-      @cdo.returnCdf = false
-    end
-
     def test_tempfile
-      ofile0, ofile1 = MyTempfile.path, MyTempfile.path
+      ofile0, ofile1 = @tempStore.newFile, @tempStore.newFile
       assert(ofile0 != ofile1, "Found equal tempfiles!")
       # Tempfile should not disappeare even if the GC was started
       puts ofile0
@@ -371,35 +541,6 @@ class TestCdo < Minitest::Test
       GC.start
       assert(File.exist?(ofile0))
     end
-
-    def test_returnCdf
-      ofile = rand(0xfffff).to_s + '_test_returnCdf.nc'
-      vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
-      assert_equal(ofile,vals)
-      @cdo.returnCdf = true
-      vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => 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.returnCdf = false
-      vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
-      assert_equal(ofile,vals)
-      FileUtils.rm(ofile)
-    end
-    def test_simple_returnCdf
-      ofile0, ofile1 = MyTempfile.path, MyTempfile.path
-      sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),
-                 :returnCdf => true).var("P").get
-      assert_equal(1013.25,sum.min)
-      sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),:output => ofile0)
-      assert_equal(ofile0,sum)
-      test_returnCdf
-    end
-    def test_readCdf
-      input = "-settunits,days  -setyear,2000 -for,1,4"
-      cdfFile = @cdo.copy(:options =>"-f nc",:input=>input)
-      cdf     = @cdo.readCdf(cdfFile)
-      assert_empty(['lon','lat','for','time'] - cdf.var_names)
-    end
     def test_selIndexListFromIcon
       input = "~/data/icon/oce.nc"
     end
@@ -456,71 +597,12 @@ class TestCdo < Minitest::Test
                             {:y => vFm1s,:style => 'points',:title => 'fillmiss2'}],
                             plotConf: {:yrange => '[0:1]'},title: 'r10x1') if @@show
     end
-  end
-
-  def test_env
-    oTag     = 'test_env_with_splitlevel_'
-    levels   = [0,10,100]
-    expected = levels.map {|l| "test_env_with_splitlevel_000#{l.to_s.rjust(3,'0')}"}
-    # clean up first
-    rm(Dir.glob(oTag+'*'))
-
-    # oType = grb (default)
-    ofiles = expected.map {|f| f += '.grb'}
-    @cdo.splitlevel(input: "-stdatm,0,10,100",output: oTag)
-    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
-    rm(ofiles)
-
-    # oType = nc, from cdo options
-    ofiles = expected.map {|f| f += '.nc'}
-    @cdo.splitlevel(input: "-stdatm,0,10,100",output: oTag,options: '-f nc')
-    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
-    rm(ofiles)
-
-    # oType = nc, from input type
-    ofiles = expected.map {|f| f += '.nc'}
-    @cdo.splitlevel(input: @cdo.stdatm(0,10,100,options: '-f nc'),output: oTag)
-    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
-    rm(ofiles)
-
-    # oType = nc, from input ENV
-    ofiles = expected.map {|f| f += '.nc2'}
-    @cdo.env = {'CDO_FILE_SUFFIX' => '.nc2'}
-    @cdo.splitlevel(input: @cdo.stdatm(0,10,100,options: '-f nc'),output: oTag)
-    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
-    rm(ofiles)
 
-    # oType = nc, from input ENV setting for each call
-    ofiles = expected.map {|f| f += '.nc4'}
-    @cdo.splitlevel(input: @cdo.stdatm(0,10,100,options: '-f nc'),output: oTag,env: {'CDO_FILE_SUFFIX' => '.nc4'})
-    assert_equal(ofiles,Dir.glob(oTag+'*').sort)
-    rm(ofiles)
-  end
-  def test_log
-    cmd = '-fldmean -mul -random,r20x20 -topo,r20x20'
-    #  logging without a real file
-    @cdo = Cdo.new(                    returnNilOnError: true)
-    @cdo.debug = false
-    @cdo.logging = true
-    @cdo.topo
-    @cdo.temp
-    @cdo.sinfov(input: cmd)
-    puts @cdo.showLog
-    @cdo.sinfov(input: '-top')
-    @cdo.topo
-    puts @cdo.showLog
-    #  use a use definded file for looging
-    @cdo = Cdo.new(logFile: 'test.log',logging: true, returnNilOnError: true)
-    @cdo.topo
-    @cdo.temp
-    @cdo.sinfov(input: cmd)
-    puts @cdo.showLog
-  end
-  def test_noOutputOps
-    c = Cdo.new
-    opsCounf = c.noOutputOps.size
-    assert(opsCounf > 50)
-    assert(opsCounf < 200)
+    # opendap test - broken since 1.9.0
+    def test_opendap
+      ifile = 'https://www.esrl.noaa.gov/psd/thredds/dodsC/Datasets/cpc_global_precip/precip.1979.nc'
+      @cdo.sinfov(input: ifile)
+    end if @@debug
   end
 end
 
@@ -584,10 +666,10 @@ end
 #  @cdo.expr("'t=#{TEMP_EXPR['geopotheight']}'", :input => ifile, :output => tempFile)
 #
 #
-#  # TIPS: I often work with temporary files and for getting rid of handling them manually the MyTempfile module can be used:
+#  # TIPS: I often work with temporary files and for getting rid of handling them manually the CdoTempfileStore module can be used:
 #  #       Simply include the following methods into you scripts and use tfile for any temporary variable
 #  def tfile
-#    MyTempfile.path
+#    CdoTempfileStore.path
 #  end
 #  # As an example, the computation of simple atmospherric density could look like
 #  presFile, tempFile = tfile, tfile
@@ -596,6 +678,6 @@ end
 #  @cdo.chainCall("setname,#{rho} -divc,#{C_R} -div",in: [presFile,tempFile].join(' '), out: densityFile)
 #
 #  # For debugging, it is helpfull, to avoid the automatic cleanup at the end of the scripts:
-#  MyTempfile.setPersist(true)
+#  CdoTempfileStore.setPersist(true)
 #  # creates randomly names files. Switch on debugging with
 #  @cdo.Debug = true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cdo
 version: !ruby/object:Gem::Version
-  version: 1.3.6
+  version: 1.4.0
 platform: ruby
 authors:
 - Ralf Mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-03 00:00:00.000000000 Z
+date: 2018-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: unifiedPlot