cdo 1.2.7 → 1.3.0

data/lib/cdo_lib.rb

@@ -0,0 +1,415 @@
+require 'pp'
+require 'open3'
+require 'logger'
+require 'stringio'
+
+# Copyright (C) 2011-2013 Ralf Mueller, ralf.mueller@zmaw.de
+# See COPYING file for copying and redistribution conditions.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# ==============================================================================
+# CDO calling mechnism
+module Cdo
+
+  VERSION = "1.2.5"
+  @@file  = StringIO.new
+
+  State = {
+    :debug       => false,
+    :returnCdf   => false,
+    :operators   => [],
+    :forceOutput => true,
+    :env         => {},
+    :log         => false,
+    :logger      => Logger.new(@@file),
+  }
+  State[:debug] = ENV.has_key?('DEBUG')
+  State[:logger].formatter = proc do |serverity, time, progname, msg|
+    msg
+  end
+
+  @@CDO = ENV['CDO'].nil? ? 'cdo' : ENV['CDO']
+
+  # Since cdo-1.5.4 undocumented operators are given with the -h option. For
+  # earlier version, they have to be provided manually
+  @@undocumentedOperators = %w[anomaly beta boxavg change_e5lsm change_e5mask
+    change_e5slm chisquare chvar cloudlayer cmd com command complextorect
+    covar0 covar0r daycount daylogs del29feb delday delete deltap deltap_fl
+    delvar diffv divcoslat dumplogo dumplogs duplicate eca_r1mm enlargegrid
+    ensrkhistspace ensrkhisttime eof3d eof3dspatial eof3dtime export_e5ml
+    export_e5res fc2gp fc2sp fillmiss fisher fldcovar fldrms fourier fpressure
+    gather gengrid geopotheight ggstat ggstats globavg gp2fc gradsdes
+    gridverify harmonic hourcount hpressure import_e5ml import_e5res
+    import_obs imtocomplex infos infov interpolate intgrid intgridbil
+    intgridtraj intpoint isosurface lmavg lmean lmmean lmstd log lsmean
+    meandiff2test mergegrid mod moncount monlogs mrotuv mrotuvb mulcoslat ncode
+    ncopy nmltest normal nvar outputbounds outputboundscpt outputcenter
+    outputcenter2 outputcentercpt outputkey outputtri outputvector outputvrml
+    pardup parmul pinfo pinfov pressure_fl pressure_hl read_e5ml remapcon1
+    remapdis1 retocomplex scalllogo scatter seascount select selgridname
+    seloperator selvar selzaxisname setrcaname setvar showvar sinfov smemlogo
+    snamelogo sort sortcode sortlevel sortname sorttaxis sorttimestamp sortvar
+    sp2fc specinfo spectrum sperclogo splitvar stimelogo studentt template1
+    template2 test test2 testdata thinout timcount timcovar tinfo transxy trms
+    tstepcount vardes vardup varmul varquot2test varrms vertwind write_e5ml
+    writegrid writerandom yearcount]
+
+  @@outputOperatorsPattern = /(diff|info|output|griddes|zaxisdes|show|ncode|ndate|nlevel|nmon|nvar|nyear|ntime|npar|gradsdes|pardes)/
+
+  private
+  def Cdo.getOperators(force=false)
+    # Do NOT compute anything, if it is not required
+    return State[:operators] unless (State[:operators].empty? or force)
+    cmd       = @@CDO + ' 2>&1'
+    help      = IO.popen(cmd).readlines.map {|l| l.chomp.lstrip}
+    if 5 >= help.size
+      warn "Operators could not get listed by running the CDO binary (#{@@CDO})"
+      pp help if Cdo.debug
+      exit
+    end
+    # in version 1.5.6 the output of '-h' has changed
+    State[:operators] = case 
+                        when Cdo.version < "1.5.6"
+                          (help[help.index("Operators:")+1].split + @@undocumentedOperators).uniq
+                        when Cdo.version <= "1.7.0"
+                          help[(help.index("Operators:")+1)..help.index(help.find {|v| v =~ /CDO version/}) - 2].join(' ').split
+                        else
+                          IO.popen(@@CDO + ' --operators').readlines.map {|l| l.split(' ').first}
+                        end
+  end
+
+  def Cdo.hasError(cmd,retvals)
+    if (State[:debug])
+      puts("RETURNCODE: #{retvals[:returncode]}")
+    end
+    if ( 0 != retvals[:returncode] )
+      puts("Error in calling:")
+      puts(">>> "+cmd+"<<<")
+      puts(retvals[:stderr])
+      return true
+    else
+      return false
+    end
+  end
+
+  def Cdo.env=(envHash)
+    State[:env] = envHash
+  end
+  def Cdo.env; State[:env]; end
+
+  def Cdo.call(cmd)
+    if (State[:debug])
+      puts '# DEBUG ====================================================================='
+      pp Cdo.env unless Cdo.env.empty?
+      puts 'CMD: '
+      puts cmd
+      puts '# DEBUG ====================================================================='
+    end
+    stdin, stdout, stderr, wait_thr = Open3.popen3(Cdo.env,cmd)
+
+    {
+      :stdout     => stdout.read,
+      :stderr     => stderr.read,
+      :returncode => wait_thr.value.exitstatus
+    }
+  end
+
+  def Cdo.run(cmd,ofile='',options='',returnCdf=false,force=nil,returnArray=nil,returnMaArray=nil)
+    cmd = "#{@@CDO} -O #{options} #{cmd} "
+    case ofile
+    when $stdout
+      retvals = Cdo.call(cmd)
+      State[:logger].info(cmd+"\n") if State[:log]
+      unless hasError(cmd,retvals)
+        return retvals[:stdout].split($/).map {|l| l.chomp.strip}
+      else
+        raise ArgumentError,"CDO did NOT run successfully!"
+      end
+    else
+      force = State[:forceOutput] if force.nil?
+      if force or not File.exists?(ofile.to_s)
+        ofile = MyTempfile.path if ofile.nil?
+        cmd << "#{ofile}"
+        retvals = call(cmd)
+        State[:logger].info(cmd+"\n") if State[:log]
+        if hasError(cmd,retvals)
+          raise ArgumentError,"CDO did NOT run successfully!"
+        end
+      else
+        warn "Use existing file '#{ofile}'" if Cdo.debug
+      end
+    end
+    if not returnArray.nil?
+      Cdo.readArray(ofile,returnArray)
+    elsif not returnMaArray.nil?
+      Cdo.readMaArray(ofile,returnMaArray)
+    elsif 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}
+    # join input streams together if possible
+    io[:input] = io[:input].join(' ') if io[:input].respond_to?(:join)
+    return [io,opts]
+  end
+
+  def Cdo.method_missing(sym, *args, &block)
+    ## args is expected to look like [opt1,...,optN,:input => iStream,:output => 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)
+      io, opts = Cdo.parseArgs(args)
+      if @@outputOperatorsPattern.match(sym)
+        run(" -#{sym.to_s}#{opts} #{io[:input]} ",$stdout)
+      else
+        run(" -#{sym.to_s}#{opts} #{io[:input]} ",io[:output],io[:options],io[:returnCdf],io[:force],io[:returnArray],io[:returnMaArray])
+      end
+    else
+      raise ArgumentError,"Operator #{sym.to_s} not found"
+    end
+  end
+
+  def Cdo.loadCdf
+    begin
+      require "numru/netcdf_miss"
+      include NumRu
+    rescue LoadError
+      warn "Could not load ruby's netcdf bindings. Please install it."
+      raise
+    end
+  end
+
+  def Cdo.getSupportedLibs(force=false)
+    return unless (State[:libs].nil? or force)
+    _, _, stderr, _ = Open3.popen3(@@CDO + " -V")
+    supported       = stderr.readlines.map(&:chomp)
+    with            = supported.grep(/(with|Features)/)[0].split(':')[1].split.map(&:downcase)
+    libs            = supported.grep(/library version/).map {|l| 
+      l.strip.split(':').map {|l| 
+        l.split.first.downcase
+      }[0,2]
+    }
+    State[:libs] = {}
+    with.flatten.each {|k| State[:libs][k]=true}
+    libs.each {|lib,version| State[:libs][lib] = version}
+  end
+
+  public
+  def Cdo.debug=(value)
+    State[:debug] = value
+  end
+  def Cdo.debug
+    State[:debug]
+  end
+  def Cdo.forceOutput=(value)
+    State[:forceOutput] = value
+  end
+  def Cdo.forceOutput
+    State[:forceOutput]
+  end
+  def Cdo.log=(value)
+    State[:log] = value
+  end
+
+  def Cdo.log
+    State[:log]
+  end
+
+  def Cdo.version
+    cmd     = @@CDO + ' 2>&1'
+    help    = IO.popen(cmd).readlines.map {|l| l.chomp.lstrip}
+    regexp  = %r{CDO version (\d.*), Copyright}
+    line    = help.find {|v| v =~ regexp}
+    version = regexp.match(line)[1]
+  end
+
+  def Cdo.setReturnCdf(value=true)
+    if value
+      Cdo.loadCdf
+    end
+    State[:returnCdf] = value
+  end
+
+  def Cdo.unsetReturnCdf
+    setReturnCdf(false)
+  end
+
+  def Cdo.returnCdf
+    State[:returnCdf]
+  end
+
+  def Cdo.hasCdo?(bin=@@CDO)
+    return true if File.exists?(@@CDO) and File.executable?(@@CDO)
+    ENV['PATH'].split(File::PATH_SEPARATOR).each {|path| 
+      return true if File.exists?([path,bin].join(File::SEPARATOR))
+    }
+  end
+
+  # test if @@CDO can be used
+  def Cdo.checkCdo
+    unless hasCdo?(@@CDO)
+      warn "Testing application #@@CDO is not available!"
+      exit 1
+    else
+      puts "Using CDO: #@@CDO"
+      puts IO.popen(@@CDO + " -V").readlines
+    end
+    return true
+  end
+
+  def Cdo.setCdo(cdo)
+    puts "Will use #{cdo} instead of #@@CDO" if Cdo.debug
+    @@CDO = cdo
+    Cdo.getOperators(true)
+    Cdo.getSupportedLibs(true)
+  end
+
+  def Cdo.getCdo
+    @@CDO
+  end
+
+  def Cdo.operators
+    Cdo.getOperators if State[:operators].empty?
+    State[:operators]
+  end
+
+  def Cdo.libs
+    getSupportedLibs
+    State[:libs]
+  end
+
+  def Cdo.hasLib?(lib)
+    return Cdo.libs.has_key?(lib)
+    return false
+  end
+
+  def Cdo.libsVersion(lib)
+    unless Cdo.hasLib?(lib)
+      raise ArgumentError, "Cdo does NOT have support for '#{lib}'"
+    else
+      if State[:libs][lib].kind_of? String
+        return State[:libs][lib]
+      else
+        warn "No version information available about '#{lib}'"
+        return false
+      end
+    end
+  end
+
+  def Cdo.showlog
+    @@file.rewind
+    puts @@file.read
+  end
+
+  #==================================================================
+  # Addional operotors:
+  #------------------------------------------------------------------
+  def Cdo.boundaryLevels(args)
+    ilevels         = Cdo.showlevel(:input => args[:input])[0].split.map(&:to_f)
+    bound_levels    = Array.new(ilevels.size+1)
+    bound_levels[0] = 0
+    (1..ilevels.size).each {|i| 
+      bound_levels[i] =bound_levels[i-1] + 2*(ilevels[i-1]-bound_levels[i-1])
+    }
+    bound_levels
+  end
+
+  def Cdo.thicknessOfLevels(args)
+    bound_levels = Cdo.boundaryLevels(args)
+    delta_levels    = []
+    bound_levels.each_with_index {|v,i| 
+      next if 0 == i
+      delta_levels << v - bound_levels[i-1]
+    }
+    delta_levels
+  end
+
+  def Cdo.readCdf(iFile)
+    Cdo.loadCdf unless State[:returnCdf] 
+    NetCDF.open(iFile)
+  end
+
+  def Cdo.openCdf(iFile)
+    Cdo.loadCdf unless State[:returnCdf] 
+    NetCDF.open(iFile,'r+')
+  end
+
+  def Cdo.readArray(iFile,varname)
+    filehandle = Cdo.readCdf(iFile)
+    if filehandle.var_names.include?(varname)
+      # return the data array
+      filehandle.var(varname).get
+    else
+      raise ArgumentError, "Cannot find variable '#{varname}'"
+    end
+  end
+
+  def Cdo.readMaArray(iFile,varname)
+    filehandle = Cdo.readCdf(iFile)
+    if filehandle.var_names.include?(varname)
+      # return the data array
+      filehandle.var(varname).get_with_miss
+    else
+      raise ArgumentError,"Cannot find variable '#{varname}'"
+    end
+  end
+
+  def Cdo.help(operator=nil)
+    if operator.nil?
+      puts Cdo.call([@@CDO,'-h'].join(' '))[:stderr]
+    else
+      operator = operator.to_s unless String == operator.class
+      if Cdo.operators.include?(operator)
+        puts Cdo.call([@@CDO,'-h',operator].join(' '))[:stdout]
+      else
+        puts "Unknown operator #{operator}"
+      end
+    end
+  end
+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
+  end
+
+  def MyTempfile.path
+    unless @@persistent_tempfiles
+      t = Tempfile.new(self.class.to_s)
+      @@_tempfiles << t
+      @@_tempfiles << t.path
+      t.path
+    else
+      t = "_"+rand(@@N).to_s
+      @@_tempfiles << t
+      t
+    end
+  end
+
+  def MyTempfile.showFiles
+    @@_tempfiles.each {|f| print(f+" ") if f.kind_of? String}
+  end
+end

data/test/test_cdo.rb

@@ -9,91 +9,88 @@ require 'pp'
 #===============================================================================
 def rm(files); files.each {|f| FileUtils.rm(f) if File.exists?(f)};end
 
+@show = ENV.has_key?('SHOW')
+
 class TestCdo < Minitest::Test
 
   DEFAULT_CDO_PATH = 'cdo'
 
+  def setup
+    @cdo = Cdo.new
+  end
+
   def test_cdo
-    assert_equal(true,Cdo.checkCdo)
+    assert_equal(true,@cdo.check)
     if ENV['CDO']
-      assert_equal(ENV['CDO'],Cdo.getCdo)
+      assert_equal(ENV['CDO'],@cdo.cdo)
     else
-      assert_equal(DEFAULT_CDO_PATH,Cdo.getCdo)
+      assert_equal(DEFAULT_CDO_PATH,@cdo.cdo)
     end
-    newCDO="#{ENV['HOME']}/local/bin/cdo"
+    newCDO="#{ENV['HOME']}/local/bin/cdo-dev"
     if File.exist?(newCDO) then
-      Cdo.setCdo(newCDO)
-      assert_equal(true,Cdo.checkCdo)
-      assert_equal(newCDO,Cdo.getCdo)
+      cdo = Cdo.new(:cdo => newCDO)
+      assert_equal(true,cdo.check)
+      assert_equal(newCDO,cdo.cdo)
     end
   end
   def test_getOperators
     %w[for random stdatm info showlevel sinfo remap geopotheight mask topo thicknessOfLevels].each {|op|
       if ["thicknessOfLevels"].include?(op)
-        assert(Cdo.respond_to?(op),"Operator '#{op}' not found")
+        assert(@cdo.respond_to?(op),"Operator '#{op}' not found")
       else
-        assert(Cdo.getOperators.include?(op),"Operator '#{op}' not found")
+        assert(@cdo.operators.include?(op),"Operator '#{op}' not found")
       end
     }
-    assert(Cdo.respond_to?('diff')) # an alias
+    assert(@cdo.operators.include?('diff'),"Operator alias 'diff' is not callable")
   end
   def test_listAllOperators
-    print Cdo.operators.join("\n")
+    assert(@cdo.operators.size > 700,"cound not find enough operators")
   end
 
   def test_outputOperators
-    Cdo.debug = true
-    levels = Cdo.showlevel(:input => "-stdatm,0")
+    @cdo.debug = true
+    levels = @cdo.showlevel(:input => "-stdatm,0")
     assert_equal([0,0].map(&:to_s),levels)
 
-    info = Cdo.sinfo(:input => "-stdatm,0")
-    assert_equal("File format: GRIB",info[0])
+    info = @cdo.sinfo(:input => "-stdatm,0")
+    assert_equal("GRIB",info[0].split(':').last.strip)
 
-    values = Cdo.outputkey("value",:input => "-stdatm,0")
-    assert_equal(["1013.25", "288"],values)
-    values = Cdo.outputkey("value",:input => "-stdatm,0,10000")
-    assert_equal(["1013.25", "271.913", "288", "240.591"],values)
-    values = Cdo.outputkey("level",:input => "-stdatm,0,10000")
-    assert_equal(["0", "10000","0", "10000"],values)
+    values = @cdo.outputkey("value",:input => "-stdatm,0")
+    assert_equal(["1013.25", "288"],values[-2..-1])
+    values = @cdo.outputkey("value",:input => "-stdatm,0,10000")
+    assert_equal(["1013.25", "271.913", "288", "240.591"],values[-4..-1])
+    values = @cdo.outputkey("level",:input => "-stdatm,0,10000")
+    assert_equal(["0", "10000","0", "10000"],values[-4..-1])
   end
   def test_CDO_version
-    assert("1.4.3.1" < Cdo.version,"Version to low: #{Cdo.version}")
+    assert("1.4.3.1" < @cdo.version,"Version too low: #{@cdo.version}")
+    assert("1.8.0" > @cdo.version,"Version too high: #{@cdo.version}")
   end
   def test_args
-    ofile0 = Cdo.stdatm(0,20,40,80,200,230,400,600,1100)
-    ofile1 = Cdo.intlevel(0,10,50,100,500,1000,  :input => ofile0)
-    ofile2 = Cdo.intlevel([0,10,50,100,500,1000],:input => ofile0)
-    ofile3 = Cdo.sub(:input => [ofile1,ofile2].join(' '))
-    info = Cdo.infon(:input => ofile3)
+    ofile0 = @cdo.stdatm(0,20,40,80,200,230,400,600,1100)
+    ofile1 = @cdo.intlevel(0,10,50,100,500,1000,  :input => ofile0)
+    ofile2 = @cdo.intlevel([0,10,50,100,500,1000],:input => ofile0)
+    ofile3 = @cdo.sub(:input => [ofile1,ofile2].join(' '))
+    info = @cdo.infon(:input => ofile3)
     (1...info.size).each {|i| assert_equal(0.0,info[i].split[-1].to_f)}
   end
   def test_operator_options
-    Cdo.debug=true
+    @cdo.debug=true
     targetLevels = [0,10,50,100,200,400,1000]
-    levels = Cdo.showlevel(:input => " -stdatm,#{targetLevels.join(',')}")
+    levels = @cdo.showlevel(:input => " -stdatm,#{targetLevels.join(',')}")
     [0,1].each {|i| assert_equal(targetLevels.join(' '),levels[i])}
-  end
-  def test_CDO_options
-    names = Cdo.showname(:input => "-stdatm,0",:options => "-f nc")
+    names = @cdo.showname(:input => "-stdatm,0",:options => "-f nc")
     assert_equal(["P T"],names)
-
-    if Cdo.hasLib?("sz")
-      ofile = Cdo.topo(:output => ofile,:options => "-z szip")
-      assert_equal(["GRIB SZIP"],Cdo.showformat(:input => ofile))
-    else
-      ofile = Cdo.topo
-      assert_equal(["GRIB"],Cdo.showformat(:input => ofile))
-    end
   end
   def test_chain
-    Cdo.debug = true
-    ofile = Cdo.setname('veloc',:input => " -copy -random,r1x1",:options => "-f nc")
-    assert_equal(["veloc"],Cdo.showname(:input => ofile))
+    @cdo.debug = true
+    ofile = @cdo.setname('veloc',:input => " -copy -random,r1x1",:options => "-f nc")
+    assert_equal(["veloc"],@cdo.showname(:input => ofile))
   end
 
   def test_diff
-    diffv_ = Cdo.diffn(:input => "-random,r1x1 -random,r1x1")
-    diff_  = Cdo.diffv(:input => "-random,r1x1 -random,r1x1")
+    diffv_ = @cdo.diffn(:input => "-random,r1x1 -random,r1x1")
+    diff_  = @cdo.diffv(:input => "-random,r1x1 -random,r1x1")
     return
 
     assert_equal(diffv[1].split(' ')[-1],"random")
@@ -102,34 +99,29 @@ class TestCdo < Minitest::Test
     assert_equal(diff[1].split(' ')[-3],"0.53060")
   end
 
-  def test_operators
-    assert_includes(Cdo.operators,"infov")
-    assert_includes(Cdo.operators,"showlevel")
-  end
-
   def test_bndLevels
-    ofile = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc")
+    ofile = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc")
     assert_equal([0, 50.0, 150.0, 350.0, 650.0, 1100.0, 1700.0, 2500.0, 3500.0, 4500.0, 5500.0],
-                 Cdo.boundaryLevels(:input => "-selname,T #{ofile}"))
+                 @cdo.boundaryLevels(:input => "-selname,T #{ofile}"))
     assert_equal([50.0, 100.0, 200.0, 300.0, 450.0, 600.0, 800.0, 1000.0, 1000.0, 1000.0],
-                 Cdo.thicknessOfLevels(:input => ofile))
+                 @cdo.thicknessOfLevels(:input => ofile))
   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.setReturnCdf
+    @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
+    diff = @cdo.sub(:input => [ofile0,ofile1].join(' ')).var('T').get
     assert_equal(0.0,diff.min)
     assert_equal(0.0,diff.max)
-    Cdo.setReturnCdf(false)
+    @cdo.returnCdf = false
   end
 
   def test_tempfile
     ofile0, ofile1 = MyTempfile.path, MyTempfile.path
-    assert_not_equal(ofile0,ofile1)
+    assert(ofile0 != ofile1, "Found equal tempfiles!")
     # Tempfile should not disappeare even if the GC was started
     puts ofile0
     assert(File.exist?(ofile0))
@@ -139,49 +131,49 @@ class TestCdo < Minitest::Test
 
   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")
+    vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
     assert_equal(ofile,vals)
-    Cdo.setReturnCdf
-    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
+    @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.unsetReturnCdf
-    vals = Cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
+    @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"),
+    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)
+    sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),:output => ofile0)
     assert_equal(ofile0,sum)
     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])
+    outs << @cdo.stdatm(0,10,20)
+    outs << @cdo.stdatm(0,10,20)
+    assert(outs[0] != outs[1])
 
     # deticated output, force = true
     outs.clear
-    outs << Cdo.stdatm(0,10,20,:output => 'test_force')
+    outs << @cdo.stdatm(0,10,20,:output => 'test_force')
     mtime0 = File.stat(outs[-1]).mtime
-    outs << Cdo.stdatm(0,10,20,:output => 'test_force')
+    outs << @cdo.stdatm(0,10,20,:output => 'test_force')
     mtime1 = File.stat(outs[-1]).mtime
-    assert_not_equal(mtime0,mtime1)
+    assert(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,:output => ofile,:force => false)
+    outs << @cdo.stdatm(0,10,20,:output => ofile,:force => false)
     mtime0 = File.stat(outs[-1]).mtime
-    outs << Cdo.stdatm(0,10,20,:output => ofile,:force => false)
+    outs << @cdo.stdatm(0,10,20,:output => ofile,:force => false)
     mtime1 = File.stat(outs[-1]).mtime
     assert_equal(mtime0,mtime1)
     assert_equal(outs[0],outs[1])
@@ -190,10 +182,10 @@ class TestCdo < Minitest::Test
 
     # dedicated output, global force setting
     ofile = 'test_force_global'
-    Cdo.forceOutput = false
-    outs << Cdo.stdatm(0,10,20,:output => ofile)
+    @cdo.forceOutput = false
+    outs << @cdo.stdatm(0,10,20,:output => ofile)
     mtime0 = File.stat(outs[-1]).mtime
-    outs << Cdo.stdatm(0,10,20,:output => ofile)
+    outs << @cdo.stdatm(0,10,20,:output => ofile)
     mtime1 = File.stat(outs[-1]).mtime
     assert_equal(mtime0,mtime1)
     assert_equal(outs[0],outs[1])
@@ -204,20 +196,20 @@ class TestCdo < Minitest::Test
   def test_thickness
     levels            = "25 100 250 500 875 1400 2100 3000 4000 5000".split
     targetThicknesses = [50.0,  100.0,  200.0,  300.0,  450.0,  600.0,  800.0, 1000.0, 1000.0, 1000.0]
-    assert_equal(targetThicknesses, Cdo.thicknessOfLevels(:input => "-selname,T -stdatm,#{levels.join(',')}"))
+    assert_equal(targetThicknesses, @cdo.thicknessOfLevels(:input => "-selname,T -stdatm,#{levels.join(',')}"))
   end
 
   def test_showlevels
     sourceLevels = %W{25 100 250 500 875 1400 2100 3000 4000 5000}
     assert_equal(sourceLevels,
-                 Cdo.showlevel(:input => "-selname,T #{Cdo.stdatm(*sourceLevels,:options => '-f nc')}")[0].split)
+                 @cdo.showlevel(:input => "-selname,T #{@cdo.stdatm(*sourceLevels,:options => '-f nc')}")[0].split)
   end
 
   def test_verticalLevels
-    Cdo.debug = true
+    @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(:input => "-selname,T #{Cdo.stdatm(*sourceLevels,:options => '-f nc')}")
+    thicknesses = @cdo.thicknessOfLevels(:input => "-selname,T #{@cdo.stdatm(*sourceLevels,:options => '-f nc')}")
     assert_equal(targetThicknesses,thicknesses)
   end
 
@@ -231,31 +223,31 @@ class TestCdo < Minitest::Test
   end 
 
   def test_returnArray
-    temperature = Cdo.stdatm(0,:options => '-f nc',:returnCdf => true).var('T').get.flatten[0]
-    assert_raise ArgumentError do
-      Cdo.stdatm(0,:options => '-f nc',:returnArray => 'TT')
+    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')
+    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')
+    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 = true
-    topo = Cdo.topo(:options => '-f nc',:returnMaArray => 'topo')
+    @cdo.debug = true
+    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')
+    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')
+    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')
+    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')
+    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])
@@ -263,131 +255,123 @@ class TestCdo < Minitest::Test
   end
 
   def test_errorException
-    Cdo.debug = true
+    @cdo.debug = true
     # stdout operators get get wrong input
-    assert_raise ArgumentError do
-      Cdo.showname(:input => '-for,d')
+    assert_raises ArgumentError do
+      @cdo.showname(:input => '-for,d')
     end
     # non-existing operator
-    assert_raise ArgumentError do
-      Cdo.neverDefinedOperator()
+    assert_raises ArgumentError do
+      @cdo.neverDefinedOperator()
     end
     # standard opertor get mis-spelled value
-    assert_raise ArgumentError do
-      Cdo.remapnn('r-10x10')
+    assert_raises ArgumentError do
+      @cdo.remapnn('r-10x10')
     end
     # standard operator get unexisting operator as input stream
-    assert_raise ArgumentError do
-      Cdo.remapnn('r10x10',:input => '-99topo')
+    assert_raises ArgumentError do
+      @cdo.remapnn('r10x10',:input => '-99topo')
     end
     # missing input stream
-    assert_raise ArgumentError do
-      Cdo.setname('setname')
+    assert_raises ArgumentError do
+      @cdo.setname('setname')
     end
     # missing input stream for stdout-operator
-    assert_raise ArgumentError do
-      Cdo.showname
+    assert_raises ArgumentError do
+      @cdo.showname
     end
   end
 
   def test_inputArray
     # check for file input
-    fileA = Cdo.stdatm(0)
-    fileB = Cdo.stdatm(0)
+    fileA = @cdo.stdatm(0)
+    fileB = @cdo.stdatm(0)
     files = [fileA,fileB]
-    assert_equal(Cdo.diffv(:input => files.join(' ')),
-                 Cdo.diffv(:input => files))
-    assert_nil(Cdo.diffv(:input => files).last)
+    assert_equal(@cdo.diffv(:input => files.join(' ')),
+                 @cdo.diffv(:input => files))
+    assert_nil(@cdo.diffv(:input => files).last)
     # check for operator input
-    assert_nil(Cdo.diffv(:input => ["-stdatm,0","-stdatm,0"]).last)
+    assert_nil(@cdo.diffv(:input => ["-stdatm,0","-stdatm,0"]).last)
     # check for operator input and files
-    assert_nil(Cdo.diffv(:input => ["-stdatm,0",fileB]).last)
+    assert_nil(@cdo.diffv(:input => ["-stdatm,0",fileB]).last)
   end
 
-  def test_libs
-    assert(Cdo.hasLib?("cdi"),"CDI support missing")
-    assert(Cdo.hasLib?("nc4"),"netcdf4 support missing")
-    assert(Cdo.hasLib?("netcdf"),"netcdf support missing")
-    assert_equal(false,Cdo.hasLib?("boost"))
-   #if 'thingol' == `hostname`.chomp
-   #  assert_equal('1.10.0',Cdo.libsVersion("grib_api")) if Cdo.hasLib?("grib_api") 
-   #  Cdo.debug  = true
-   #  warn "Found magics support" if Cdo.libs.has_key?('magics')
-   #  Cdo.setCdo('../../src/cdo')
-   #  assert(Cdo.libs.has_key?('magics'),"Magics support is expected in the local development binary")
-   #end
-    assert_raise ArgumentError do
-      Cdo.libsVersion("foo")
+  def test_filetypes
+    assert(@cdo.filetypes.include?("grb"),"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
   end
 
   def test_output_set_to_nil
-    assert_equal(String,Cdo.topo(:output => nil).class)
-    assert_equal("File format: GRIB",Cdo.sinfov(:input => "-topo", :output => nil)[0])
+    assert_equal(String,@cdo.topo(:output => nil).class)
+    assert_equal("File format: GRIB".tr(' ',''),@cdo.sinfov(:input => "-topo", :output => nil)[0].tr(' ',''))
   end
 
-  if 'thingol' == `hostname`.chomp  then
+  if 'luthien' == `hostname`.chomp  then
     def test_readCdf
       input = "-settunits,days  -setyear,2000 -for,1,4"
-      cdfFile = Cdo.copy(:options =>"-f nc",:input=>input)
-      cdf     = Cdo.readCdf(cdfFile)
+      cdfFile = @cdo.copy(:options =>"-f nc",:input=>input)
+      cdf     = @cdo.readCdf(cdfFile)
       assert_equal(['lon','lat','time','for'],cdf.var_names)
     end
     def test_selIndexListFromIcon
       input = "~/data/icon/oce.nc"
     end
     def test_readArray
-      ifile = '/home/ram/data/examples/EH5_AMIP_1_TSURF_1991-1995.nc'
-      assert_equal([192, 96, 10],Cdo.readArray(Cdo.seltimestep('1/10',:input => ifile), 'tsurf').shape)
+      @cdo.debug = true
+      assert_equal([40,80],@cdo.readArray(@cdo.sellonlatbox(-10,10,-20,20,:input => '-topo',:options => '-f nc'), 'topo').shape)
     end
     def test_doc
-      Cdo.debug = true
-      Cdo.help(:remap)
-      Cdo.help(:infov)
-      Cdo.help(:topo)
-      Cdo.help(:notDefinedOP)
-      Cdo.help
+      @cdo.debug = true
+      @cdo.help(:remap)
+      @cdo.help(:infov)
+      @cdo.help(:topo)
+      @cdo.help(:notDefinedOP)
+      @cdo.help
     end
     def test_fillmiss
-      Cdo.debug = true
+      @cdo.debug = true
       # check up-down replacement
-      rand = Cdo.setname('v',:input => '-random,r1x10 ', :options => ' -f nc',:output => '/tmp/rand.nc')
-      cdf  = Cdo.openCdf(rand)
+      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')
+      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')
+                            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)
+      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')
+      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')
+                            plotConf: {:yrange => '[0:1]'},title: 'r10x1') if @show
     end
   end
 
@@ -400,39 +384,54 @@ class TestCdo < Minitest::Test
 
     # oType = grb (default)
     ofiles = expected.map {|f| f += '.grb'}
-    Cdo.splitlevel(input: "-stdatm,0,10,100",output: oTag)
+    @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')
+    @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)
+    @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)
+    @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 += '.nc2'}
-    Cdo.splitlevel(input: Cdo.stdatm(0,10,100,options: '-f nc'),output: oTag,env: {'CDO_FILE_SUFFIX' => '.nc2'})
+    @cdo.splitlevel(input: @cdo.stdatm(0,10,100,options: '-f nc'),output: oTag,env: {'CDO_FILE_SUFFIX' => '.nc2'})
     assert_equal(ofiles,Dir.glob(oTag+'*').sort)
     rm(ofiles)
   end
   def test_log
-    Cdo.log = true
-    Cdo.topo
-    Cdo.showlog
+    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
 end
 
@@ -440,30 +439,30 @@ end
 #  #
 #  # merge:
 #  #   let files be an erray of valid filenames and ofile is a string
-#  Cdo.merge(:input => outvars.join(" "),:output => ofile)
+#  @cdo.merge(:input => outvars.join(" "),:output => ofile)
 #  #   or with multiple arrays:
-#  Cdo.merge(:input => [ifiles0,ifiles1].flatten.join(' '),:output => ofile)
+#  @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)
+#    @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)
+#      @cdo.selname(varname,:input => ifile,:output => varfile)
 #    }
 #  }
 #  ths.each {|th| th.join}
 #  # another example with sub:
-#  Cdo.sub(:input => [oldfile,newfile].join(' '), :output => diff)
+#  @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)
+#  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:
@@ -473,15 +472,15 @@ end
 #             else
 #               warn "Wrong usage of variable identifier for '#{var}' (class #{var.class})!"
 #             end
-#  Cdo.send(operator,var,:input => @ifile, :output => varfile)
+#  @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)
+#  @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)
+#  @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)
+#  @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
@@ -492,8 +491,8 @@ end
 #  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)
+#  @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 MyTempfile module can be used:
@@ -503,11 +502,11 @@ end
 #  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)
+#  @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:
 #  MyTempfile.setPersist(true)
 #  # creates randomly names files. Switch on debugging with 
-#  Cdo.Debug = true
+#  @cdo.Debug = true