cdo 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2085dbda68e564e4449b83e69c840dcfc817b60adfe2010c597eeb795eade50d
-  data.tar.gz: 34c2082c1ed7de54cb889dde3cd8fe3d3e8e9ba7abd6f20f655bd6d5478e0905
+  metadata.gz: 9f41ea1d14a2640c9c93ca33eaeacb7860f39fd723e857f740dc366bc284f020
+  data.tar.gz: 2c5fb959227006a1659c7c6fa97936d85ddd5b62fc1e9c0459e9029c043c1819
 SHA512:
-  metadata.gz: 38f8689cf9674697d64c9958df35c85177e86c08d6becaa808cc13a56c460fcbce6a6f57c43ca376c129c531c26a1b09dbae38a07c1557e36ec1746f4365ca50
-  data.tar.gz: 71d527c68c39531e5b3c8007a05fa0b46989efa4b49da2a4e3738ced45d60137d32071bfe77a2da11273a6a716f0c9e17484a4676680825f480633289521f921
+  metadata.gz: c1fea4d7b5c61a989b6b7ecab617604ab4977f771b072b8441149bd141a4fa95e0cfc5cc1e520d34f3c644c4d21fe15092ac332719ed526a03fc3edd9be657d5
+  data.tar.gz: 7e687fc0d277d2123eb815012ad023d38480b631e0414f33503928d09e39fc0dc12a3b22e2d259bd23d0343d668c3d2a8d5b781ea200c9d65d66218022b6cab1

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

data/lib/cdo.rb

@@ -35,18 +35,17 @@ class Cdo
 
 
   attr_accessor :cdo, :returnCdf, :forceOutput, :env, :debug, :logging, :logFile
-  attr_reader   :operators, :filetypes
+  attr_reader   :operators, :filetypes, :hasNetcdf
 
   def initialize(cdo: 'cdo',
-                 returnCdf: false,
                  returnFalseOnError: false,
+                 returnNilOnError: false,
                  forceOutput: true,
                  env: {},
+                 debug: false,
                  tempdir: Dir.tmpdir,
                  logging: false,
-                 logFile: StringIO.new,
-                 debug: false,
-                 returnNilOnError: false)
+                 logFile: StringIO.new)
 
     # setup path to cdo executable
     @cdo = ENV.has_key?('CDO') ? ENV['CDO'] : cdo
@@ -54,12 +53,12 @@ class Cdo
     @operators              = getOperators(@cdo)
     @noOutputOperators      = @operators.select {|op,io| 0 == io}.keys
 
-    @returnCdf              = returnCdf
+    @hasNetcdf              = loadOptionalLibs
+
     @forceOutput            = forceOutput
     @env                    = env
     @debug                  = ENV.has_key?('DEBUG') ? true : debug
     @returnNilOnError       = returnNilOnError
-
     @returnFalseOnError     = returnFalseOnError
 
     @tempStore              = CdoTempfileStore.new(tempdir)
@@ -76,6 +75,13 @@ class Cdo
         v
       end
     }
+
+    # ignore return code 1 for diff operators (from 1.9.6 onwards)
+    @exit_success = lambda {|operatorName|
+      return 0 if version < '1.9.6'
+      return 0 if 'diff' != operatorName[0,4]
+      return 1
+    }
   end
 
   private # {{{
@@ -209,11 +215,11 @@ class Cdo
   end
 
   # Error handling for the given command
-  def _hasError(cmd,retvals)
+  def _hasError(cmd,operatorName,retvals)
     if @debug
       puts("RETURNCODE: #{retvals[:returncode]}")
     end
-    if ( 0 != retvals[:returncode] )
+    if ( @exit_success[operatorName] < retvals[:returncode] )
       puts("Error in calling:")
       puts(">>> "+cmd+"<<<")
       puts(retvals[:stderr])
@@ -260,7 +266,7 @@ class Cdo
     case output
     when $stdout
       retvals = _call(cmd,env)
-      unless _hasError(cmd,retvals)
+      unless _hasError(cmd,operatorName,retvals)
         _output = retvals[:stdout].split($/).map {|l| l.chomp.strip}
         unless autoSplit.nil?
           _output.map! {|line| line.split(autoSplit)}
@@ -290,7 +296,7 @@ class Cdo
 
         retvals = _call(cmd,env)
 
-        if _hasError(cmd,retvals)
+        if _hasError(cmd,operatorName,retvals)
           if @returnNilOnError then
             return nil
           else
@@ -309,7 +315,7 @@ class Cdo
       readArray(outputs[0],returnArray)
     elsif not returnMaArray.nil?
       readMaArray(outputs[0],returnMaArray)
-    elsif returnCdf or @returnCdf
+    elsif returnCdf
       retval = outputs.map{|f| readCdf(f)}
       return 1 == retval.size ? retval[0] : retval
     elsif /^split/.match(operatorName)
@@ -344,12 +350,13 @@ class Cdo
   end
 
   # load the netcdf bindings
-  def loadCdf
+  def loadOptionalLibs
     begin
       require "numru/netcdf_miss"
-    rescue LoadError
-      warn "Could not load ruby's netcdf bindings. Please install it."
-      raise
+      return true
+    rescue
+      warn "Could not load ruby's netcdf bindings"
+      return false
     end
   end
 
@@ -411,15 +418,17 @@ class Cdo
   end
 
   # return cdf handle to given file readonly
-  def readCdf(iFile)
-    loadCdf
-    NumRu::NetCDF.open(iFile)
+  def readCdf(iFile,mode='r')
+    if @hasNetcdf then
+      NumRu::NetCDF.open(iFile,mode)
+    else
+      raise LoadError,"Could not load ruby-netcdf"
+    end
   end
 
   # return cdf handle opened in append more
   def openCdf(iFile)
-    loadCdf
-    NumRu::NetCDF.open(iFile,'r+')
+    readCdf(iFile,'r+')
   end
 
   # return narray for given variable name

data/test/test_cdo.rb

@@ -66,6 +66,14 @@ class TestCdo < Minitest::Test
     assert(@cdo.operators.size > 700,"cound not find enough operators")
   end
 
+  def test_verifyGridOP
+    if "1.9.5" >= @cdo.version then
+      assert(@cdo.operators.keys.include?('gridverify'))
+    else
+      assert(@cdo.operators.keys.include?('verifygrid'))
+    end
+  end
+
   def test_outputOperators
     @cdo.debug = @@debug
     levels = @cdo.showlevel(:input => "-stdatm,0")
@@ -214,11 +222,11 @@ class TestCdo < Minitest::Test
   end
 
   def test_parseArgs
-    io,opts = Cdo.parseArgs([1,2,3,:input => '1',:output => '2',:force => true,:returnCdf => "T",:autoSplit => '  '])
+    io,opts = Cdo.parseArgs([1,2,3,:input => '1',:output => '2',:force => true,:returnCdf => true,:autoSplit => '  '])
     assert_equal("1",io[:input])
     assert_equal("2",io[:output])
     assert_equal(true,io[:force])
-    assert_equal("T",io[:returnCdf])
+    assert_equal(true,io[:returnCdf])
     assert_equal("  ",io[:autoSplit])
     pp [io,opts]
   end
@@ -273,7 +281,7 @@ class TestCdo < Minitest::Test
 
   def test_noOutputOps
     operators = @cdo.operators
-    %w[griddes griddes2 gridverify info infoc infon infop infos infov map
+    %w[griddes griddes2 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|
@@ -355,91 +363,104 @@ class TestCdo < Minitest::Test
   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')
+    if @cdo.hasNetcdf then
+      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(' '))
+    else
+      assert_raises LoadError do
+        temperature = @cdo.stdatm(0,:returnCdf => true).var('T').get.flatten[0]
+      end
     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
+    if @cdo.hasNetcdf then
+      @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])
+    else
+      assert_raises LoadError do
+        topo = @cdo.topo(:returnMaArray => 'topo')
+      end
+    end
   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)
+    if @cdo.hasNetcdf then
+      vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:returnCdf => true)
+      assert_equal(["lon","lat","level","P","T"],vals.var_names)
+      assert_equal(276,vals.var("T").get.flatten.mean.floor)
+      vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
+      assert_equal(ofile,vals)
+    end
     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
+    if @cdo.hasNetcdf then
+      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
+    else
+      puts "test_simple_returnCdf is disabled because of missing ruby-netcdf"
+    end
   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)
+    if @cdo.hasNetcdf then
+      cdf = @cdo.readCdf(cdfFile)
+      assert_empty(['lon','lat','for','time'] - cdf.var_names)
+    else
+      assert_raises LoadError do
+        cdf = @cdo.readCdf(cdfFile)
+      end
+    end
   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
+    if @cdo.hasNetcdf then
+      diff = @cdo.sub(:returnCdf => true, :input => [ofile0,ofile1].join(' ')).var('T').get
+      assert_equal(0.0,diff.min)
+      assert_equal(0.0,diff.max)
+    end
   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)
+    if @cdo.hasNetcdf then
+      @cdo.debug = @@debug
+      assert_equal([40,80],@cdo.readArray(@cdo.sellonlatbox(-10,10,-20,20,:input => '-topo',:options => '-f nc'), 'topo').shape)
+    end
   end
   def test_env
     oTag     = 'test_env_with_splitlevel_'
@@ -557,45 +578,57 @@ class TestCdo < Minitest::Test
       @cdo.help
     end
     def test_fillmiss
-      @cdo.debug = @@debug
-      # check up-down replacement
-      rand = @cdo.setname('v',:input => '-random,r1x10 ', :options => ' -f nc',:output => '/tmp/rand.nc')
-      cdf  = @cdo.openCdf(rand)
-      vals = cdf.var('v').get
-      cdf.var('v').put(vals.sort)
-      cdf.sync
-      cdf.close
-
-      missRange = '0.3,0.8'
-      arOrg = @cdo.setrtomiss(missRange,:input => cdf.path,:returnMaArray => 'v')
-      arFm  = @cdo.fillmiss(:input => "-setrtomiss,#{missRange} #{cdf.path}",:returnMaArray => 'v')
-      arFm1s= @cdo.fillmiss2(:input => "-setrtomiss,#{missRange} #{cdf.path}",:returnMaArray => 'v')
-      vOrg  = arOrg[0,0..-1]
-      vFm   = arFm[0,0..-1]
-      vFm1s = arFm1s[0,0..-1]
-      UnifiedPlot.linePlot([{:y => vOrg, :style => 'line',:title => 'org'},
-                            {:y => vFm,  :style => 'points',:title => 'fillmiss'},
-                            {:y => vFm1s,:style => 'points',:title => 'fillmiss2'}],
-                            plotConf: {:yrange => '[0:1]'},title: 'r1x10') if @@show
-      # check left-right replacement
-      rand = @cdo.setname('v',:input => '-random,r10x1 ', :options => ' -f nc',:output => '/tmp/rand.nc')
-      cdf  = @cdo.openCdf(rand)
-      vals = cdf.var('v').get
-      cdf.var('v').put(vals.sort)
-      cdf.sync
-      cdf.close
-
-      missRange = '0.3,0.8'
-      arOrg = @cdo.setrtomiss(missRange,:input => cdf.path,:returnMaArray => 'v')
-      arFm  = @cdo.fillmiss(:input => "-setrtomiss,#{missRange} #{cdf.path}",:returnMaArray => 'v')
-      arFm1s= @cdo.fillmiss2(:input => "-setrtomiss,#{missRange} #{cdf.path}",:returnMaArray => 'v')
-      vOrg  =  arOrg[0..-1,0]
-      vFm   =   arFm[0..-1,0]
-      vFm1s = arFm1s[0..-1,0]
-      UnifiedPlot.linePlot([{:y => vOrg, :style => 'line',:title => 'org'},
-                            {:y => vFm,  :style => 'points',:title => 'fillmiss'},
-                            {:y => vFm1s,:style => 'points',:title => 'fillmiss2'}],
-                            plotConf: {:yrange => '[0:1]'},title: 'r10x1') if @@show
+      rand = @cdo.setname('v',
+                          :input => '-random,r1x10 ',
+                          :options => ' -f nc')
+
+      if @cdo.hasNetcdf then
+        @cdo.debug = @@debug
+        cdf  = @cdo.openCdf(rand)
+        vals = cdf.var('v').get
+        cdf.var('v').put(vals.sort)
+        cdf.sync
+        cdf.close
+      else
+        assert_raises LoadError do
+          cdf  = @cdo.openCdf(rand)
+        end
+      end
+
+      if @cdo.hasNetcdf then
+        missRange = '0.3,0.8'
+        arOrg = @cdo.setrtomiss(missRange,:input => cdf.path,:returnMaArray => 'v')
+        arFm  = @cdo.fillmiss(:input => "-setrtomiss,#{missRange} #{cdf.path}",:returnMaArray => 'v')
+        arFm1s= @cdo.fillmiss2(:input => "-setrtomiss,#{missRange} #{cdf.path}",:returnMaArray => 'v')
+        vOrg  = arOrg[0,0..-1]
+        vFm   = arFm[0,0..-1]
+        vFm1s = arFm1s[0,0..-1]
+        UnifiedPlot.linePlot([{:y => vOrg, :style => 'line',:title => 'org'},
+                              {:y => vFm,  :style => 'points',:title => 'fillmiss'},
+                              {:y => vFm1s,:style => 'points',:title => 'fillmiss2'}],
+        plotConf: {:yrange => '[0:1]'},title: 'r1x10') if @@show
+        # check left-right replacement
+        rm([rand])
+        rand = @cdo.setname('v',:input => '-random,r10x1 ', :options => ' -f nc',:output => '/tmp/rand.nc')
+        cdf  = @cdo.openCdf(rand)
+        vals = cdf.var('v').get
+        cdf.var('v').put(vals.sort)
+        cdf.sync
+        cdf.close
+
+        missRange = '0.3,0.8'
+        arOrg = @cdo.setrtomiss(missRange,:input => cdf.path,:returnMaArray => 'v')
+        arFm  = @cdo.fillmiss(:input => "-setrtomiss,#{missRange} #{cdf.path}",:returnMaArray => 'v')
+        arFm1s= @cdo.fillmiss2(:input => "-setrtomiss,#{missRange} #{cdf.path}",:returnMaArray => 'v')
+        vOrg  =  arOrg[0..-1,0]
+        vFm   =   arFm[0..-1,0]
+        vFm1s = arFm1s[0..-1,0]
+        UnifiedPlot.linePlot([{:y => vOrg, :style => 'line',:title => 'org'},
+                              {:y => vFm,  :style => 'points',:title => 'fillmiss'},
+                              {:y => vFm1s,:style => 'points',:title => 'fillmiss2'}],
+        plotConf: {:yrange => '[0:1]'},title: 'r10x1') if @@show
+        rm([rand])
+      end
     end
 
     # opendap test - broken since 1.9.0
@@ -605,79 +638,3 @@ class TestCdo < Minitest::Test
     end if @@debug
   end
 end
-
-#  # Calling simple operators
-#  #
-#  # merge:
-#  #   let files be an erray of valid filenames and ofile is a string
-#  @cdo.merge(:input => outvars.join(" "),:output => ofile)
-#  #   or with multiple arrays:
-#  @cdo.merge(:input => [ifiles0,ifiles1].flatten.join(' '),:output => ofile)
-#  # selname:
-#  #   lets grep out some variables from ifile:
-#  ["T","U","V"].each {|varname|
-#    varfile = varname+".nc"
-#    @cdo.selname(varname,:input => ifile,:output => varfile)
-#  }
-#  #   a threaded version of this could look like:
-#  ths = []
-#  ["T","U","V"].each {|outvar|
-#    ths << Thread.new(outvar) {|ovar|
-#      varfile = varname+".nc"
-#      @cdo.selname(varname,:input => ifile,:output => varfile)
-#    }
-#  }
-#  ths.each {|th| th.join}
-#  # another example with sub:
-#  @cdo.sub(:input => [oldfile,newfile].join(' '), :output => diff)
-#
-#  # It is possible too use the 'send' method
-#  operator  = /grb/.match(File.extname(ifile)) ? :showcode : :showname
-#  inputVars = @cdo.send(operator,:input => ifile)
-#  # show and info operators are writing to stdout. cdo.rb tries to collects this into arrays
-#  #
-#  # Same stuff with other operators:
-#  operator = case var
-#             when Fixnum then 'selcode'
-#             when String then 'selname'
-#             else
-#               warn "Wrong usage of variable identifier for '#{var}' (class #{var.class})!"
-#             end
-#  @cdo.send(operator,var,:input => @ifile, :output => varfile)
-#
-#  # Pass an array for operators with multiple options:
-#  #   Perform conservative remapping with pregenerated weights
-#  @cdo.remap([gridfile,weightfile],:input => copyfile,:output => outfile)
-#  #   Create vertical height levels out of hybrid model levels
-#  @cdo.ml2hl([0,20,50,100,200,400,800,1200].join(','),:input => hybridlayerfile, :output => reallayerfile)
-#  # or use multiple arguments directly
-#  @cdo.remapeta(vctfile,orofile,:input => ifile,:output => hybridlayerfile)
-#
-#  # the powerfull expr operator:
-#  # taken from the tutorial in https://code.zmaw.de/projects/cdo/wiki/Tutorial#The-_expr_-Operator
-#  SCALEHEIGHT  = 10000.0
-#  C_EARTH_GRAV = 9.80665
-#  # function for later computation of hydrostatic atmosphere pressure
-#  PRES_EXPR    = lambda {|height| "101325.0*exp((-1)*(1.602769777072154)*log((exp(#{height}/#{SCALEHEIGHT})*213.15+75.0)/288.15))"}
-#  TEMP_EXPR    = lambda {|height| "213.0+75.0*exp(-#{height}/#{SCALEHEIGHT})"}
-#
-#  # Create Pressure and Temperature out of a height field 'geopotheight' from ifile
-#  @cdo.expr("'p=#{PRES_EXPR['geopotheight']}'", :input => ifile, :output => presFile)
-#  @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 CdoTempfileStore module can be used:
-#  #       Simply include the following methods into you scripts and use tfile for any temporary variable
-#  def tfile
-#    CdoTempfileStore.path
-#  end
-#  # As an example, the computation of simple atmospherric density could look like
-#  presFile, tempFile = tfile, tfile
-#  @cdo.expr("'p=#{PRES_EXPR['geopotheight']}'", :input => ifile, :output => presFile)
-#  @cdo.expr("'t=#{TEMP_EXPR['geopotheight']}'", :input => ifile, :output => tempFile)
-#  @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:
-#  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.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Ralf Mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-19 00:00:00.000000000 Z
+date: 2019-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: unifiedPlot
@@ -109,8 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Easy access to the Climate Data operators