ctioga 1.11.1

data/lib/SciYAG/Backends/filters/trim.rb

@@ -0,0 +1,64 @@
+# trim.rb : A trimming filter
+# Copyright (C) 2007 Vincent Fourmond
+
+# 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; either version 2 of the License, or
+# (at your option) any later version.
+
+# 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.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+module SciYAG
+
+  module Backends
+
+    # Removes a given ratio of points
+    class TrimFilter < Filter
+      include Dobjects
+
+      describe "trim", "Trim", "Removes a certain number of points"
+
+      init_param 'nb', "Number", Float, 
+      "Keep one point for each nb points"
+
+      def initialize(nb) 
+        @nb = Float(nb)
+        if @nb <= 1
+          warn "Invalid parameter nb #{nb}, using 3"
+          @nb = 3
+        end
+      end
+
+      # There you go: a simple averageing filter.
+      def apply(f)
+        new_x = Dvector.new
+        new_y = Dvector.new
+        nb = 0.0
+        for x,y in f
+          if nb < 1
+            new_x << x
+            new_y << y
+          end
+          nb += 1
+          if nb  >= @nb
+            nb -= @nb
+          end
+        end
+        return Function.new(new_x, new_y)
+      end
+
+      def apply!(f)
+        new_f = apply(f)
+        f.x.replace(new_f.x)
+        f.y.replace(new_f.y)
+      end
+    end
+  end
+end

data/lib/SciYAG/Backends/gnuplot.rb

@@ -0,0 +1,131 @@
+# gnuplot.rb: a backend to extract plots from gnuplot's files
+# Copyright (C) 2007 Vincent Fourmond
+
+# 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; either version 2 of the License, or
+# (at your option) any later version.
+
+# 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.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+
+
+require 'SciYAG/Backends/backend'
+require 'Dobjects/Dvector'
+require 'Dobjects/Function'
+
+# To feed data to fancyread
+require 'stringio'
+
+
+module SciYAG
+
+  module Backends
+
+    class GnuplotBackend < Backend
+
+      include Dobjects
+      
+      describe 'gnuplot', 'Gnuplot files', <<EOD
+This backend hijacks gnuplot files to make extract data which they plot.
+No information is taken about the style !
+EOD
+
+      param_accessor :variables_overrides, 'vars', 
+      "Variable overrides", {:type => :string}, 
+      "A colon-separated override of local variables, " +
+        "such as a=1;b=3;c=5"
+
+      param_accessor :range, 'range', 
+      "Plotting X range", {:type => :string}, 
+      "The plotting X range, such as (0:2)"
+      
+      # This is called by the architecture to get the data. It splits
+      # the set name into filename@cols, reads the file if necessary and
+      # calls get_data
+      def query_xy_data(set)
+        if set =~ /(.*)@(\d+)/
+          filename = $1
+          number = $2.to_i - 1
+        else
+          filename = set
+          number = 0
+        end
+        plots = run_gnuplot(filename)
+        return Function.new(*(plots[number]))
+      end
+
+      # Runs gnuplot on the file, and returns all datasets found
+      # inside it. Cached.
+      def run_gnuplot(filename)
+        date = File::mtime(filename)
+        # Get it from the cache !
+        get_cached_entry(filename, [], {:date => date}) do
+          debug "Running gnuplot on file #{filename}"
+          f = File.open(filename)
+          # We open a bidirectionnal connection to gnuplot:
+          gnuplot = IO.popen("gnuplot", "r+")
+          output = ""
+          gnuplot.puts "set term table"
+          for line in f
+            next if line =~ /set\s+term/
+            if @variables_overrides and line =~ /plot\s+/
+              debug "Found a plot, inserting variable overrides :#{@variables_overrides}"
+              line.gsub!(/plot\s+/, "#{@variables_overrides};plot ")
+            end
+            if @range and line =~ /plot\s+/
+              debug "Found a plot, inserting range :#{@range}"
+              line.gsub!(/plot\s+(\[[^\]]+\])?/, 
+                         "plot [#{@range}]")
+            end
+            gnuplot.print line 
+            gnuplot.flush
+            output += slurp(gnuplot)
+          end
+          # Output a "\n" in the end.
+          gnuplot.puts ""
+          gnuplot.flush
+          gnuplot.close_write
+          # Then we get all that is remaining:
+          output += gnuplot.read
+          gnuplot.close
+
+          # Now, interaction with gnuplot is finished, and we want to
+          # parse that:
+          outputs = output.split("\n\n")
+          plots = []
+          for data in outputs
+            plots << Dvector.fancy_read(StringIO.new(data), [0,1])
+          end
+          # This block evaluates to plots:
+          plots
+          # DO NOT USE return !!!
+        end
+      end
+
+      # Gets all data from the given file until it blocks, and returns it.
+      def slurp(f, size = 10240)
+        str = ""
+        begin
+          while IO::select([f],[],[],0)
+            ret = f.readpartial(size)
+            if ret.empty?
+              return str
+            end
+            str += ret 
+          end
+        end
+        return str
+      end
+
+    end
+
+  end
+end

data/lib/SciYAG/Backends/math.rb

@@ -0,0 +1,108 @@
+# math.rb :This files provides the Math backend, which provides data based on
+# mathematical formulas.
+# Copyright (C) 2006 Vincent Fourmond
+
+# 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; either version 2 of the License, or
+# (at your option) any later version.
+
+# 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.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+
+require 'SciYAG/Backends/backend'
+require 'Dobjects/Dvector'
+require 'Dobjects/Function'
+
+module SciYAG
+
+  module Backends
+
+    class MathBackend < Backend
+
+      include Dobjects
+      include Math
+      
+      describe 'math', 'Mathematical functions', <<EOD
+This backend returns computations of mathematical formulas.
+EOD
+
+      param_accessor :samples, 'samples', "Samples",
+      {:type => :integer}, "The number of points"
+      param_accessor :x_range, 'xrange',  "X Range", 
+      {:type => :float_range}, "X range (a:b)"
+      param_accessor :t_range, 'trange',  "T Range", 
+      {:type => :float_range}, "T range (a:b) (parametric plot)"
+
+      param_accessor :log, 'log',  "Logarithmic scale", 
+      {:type => :boolean}, "Space samples logarithmically"
+      
+      def initialize
+        super()
+        @samples = 100
+        @x_range = -10.0..10.0
+        @t_range = -10.0..10.0
+        @log = false
+      end
+
+      # This is called by the architecture to get the data. It splits
+      # the set name into func@range, reads the file if necessary and
+      # calls get_data.
+      def query_xy_data(set)
+        if set =~ /(.*)@(.*)/
+          @x_range = ParamRange.new($2)
+          set = $1
+        end
+        return Function.new(*get_data(set))
+      end
+
+      
+      def get_data(set)
+        # Parametric plot with a : in the middle
+        if set =~ /:/
+          x_block, y_block = set.split(/:/).map { |s|
+            eval "proc {|t| #{s}}"
+          }
+
+          t_v = make_dvector(@t_range, @samples)
+          x_v = t_v.collect(&x_block)
+          y_v = t_v.collect(&y_block)
+        else
+          y_block = eval "proc {|x| #{set} }"
+          x_v = make_dvector(@x_range, @samples)
+          y_v = x_v.collect(&y_block)
+        end
+        return [x_v,y_v]
+      end
+      
+      # Turns a Range and a number of points into a Dvector
+      def make_dvector(range, nb_points, log = @log)
+        n = nb_points -1
+        a = Dvector.new(nb_points) { |i| 
+          i.to_f/(n.to_f)
+        }
+        # a is in [0:1] inclusive...
+        if log
+          delta = range.last/range.first
+          # delta is positive necessarily
+          a *= delta.log
+          a.exp!
+          a *= range.first
+        else
+          delta = range.last - range.first
+          a *= delta
+          a += range.first
+        end
+        return a
+      end
+
+    end
+  end
+end

data/lib/SciYAG/Backends/mdb.rb

@@ -0,0 +1,462 @@
+# mdb.rb : a backend that can extract electrochemical data stored within
+# MS Access databases created by the PAR PowerSuite utilities. I doubt
+# it will be useful to many people, but, well no one knows !
+
+# Copyright (C) 2006 Vincent Fourmond
+
+# 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; either version 2 of the License, or
+# (at your option) any later version.
+
+# 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.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+
+require 'SciYAG/Backends/backend'
+require 'Dobjects/Dvector'
+require 'Dobjects/Function'
+
+module SciYAG
+
+  module Backends
+
+    class MDBBackend < Backend
+
+      include Dobjects
+      
+      describe 'mdb', 'PAR PowerSuite MDB files', <<EOD, false
+Reads the MS Access files produced by the PAR electrochemistry suite.
+Abstract Backend, needs to be redefined by children.
+EOD
+
+
+      
+      # The table of the file where we want to look for data.
+      attr_accessor :data_set_table_name
+
+      # The name of the X, Y and Z columns in the table.
+      attr_accessor :data_set_x_col, :data_set_y_col, :data_set_z_col
+
+      # If this attribute is set, the sets are further split
+      # for the different values of that column
+      attr_accessor :data_set_name_col
+
+
+      # A small class to hold a data set
+      class DataSet
+        include Dobjects
+        
+        # The name of the dataset
+        attr_accessor :name
+
+        # The DataSetID property
+        attr_accessor :data_set_id
+
+        # Used internally to create a new dvector
+        def new_dvector
+          return Dvector.new(1000).resize(0)
+        end
+
+        # Returns the keys
+        def subsets
+          #         return @x_data.keys.compact # removes the nil key...
+          return @subsets.compact
+        end
+        
+        def initialize(name, data_set_id)
+          @name = name
+          @data_set_id = data_set_id
+
+          @subsets = []
+
+          @x_data = {}            # A hash indexed on the set name
+          @y_data = {}            # A hash indexed on the set name
+          @z_data = {}            # A hash indexed on the set name
+        end
+
+        # Returns the x_data for the given set
+        def x_data(set = nil)
+          return @x_data[set]
+        end
+
+        # Returns the y_data for the given set
+        def y_data(set = nil)
+          return @y_data[set]
+        end
+
+        # Returns the z_data for the given set
+        def z_data(set = nil)
+          return @z_data[set]
+        end
+
+        # Adds a point to the set
+        def add_point(x,y,z,set = nil)
+          if not @x_data[set]
+            @subsets << set
+            @x_data[set] = new_dvector
+            @y_data[set] = new_dvector
+            @z_data[set] = new_dvector
+          end
+          @x_data[set] << x
+          @y_data[set] << y
+          @z_data[set] << z
+        end
+
+      end
+
+      def initialize
+        super()
+        @data_set_table_name = nil           # has to be redefined by children
+        # A hash holding dataset_name -> DataSet object
+        @data_sets = {}
+        @data_set_id = []         # The same as upper,
+        # but with the set number
+
+        # The column for different sets
+        @data_set_name_col = "Series"
+
+        # The current database
+        @current_database = ""
+      end
+
+      # The separator for columns when reading the file.
+      COL_SEP = "###"
+      # The command to run mdb-export
+      MDB_EXPORT = "mdb-export"
+
+      # Reads a table and returns the table of lines, optionnally beginning
+      # with the header
+      def mdb_export_table(file, table, header = false)
+        cmd_line = "#{MDB_EXPORT} -Q -d '#{COL_SEP}' " + 
+          if header
+            " "
+          else
+            "-H "
+          end +
+          "'#{file}' '#{table}' "  +
+          "| sort -n"             # we sort numerically with the program sort,
+        # decently faster
+        mdb = IO.popen(cmd_line)
+        l = mdb.readlines
+        return l
+      end
+
+      # Reads a table and turns it into a list of hashes
+      def mdb_table_to_hash(file, table) 
+        pipe = IO.popen("#{MDB_EXPORT} -Q -d '#{COL_SEP}' -R '&&&&&' " +
+                        "#{file} #{table}")
+        header = pipe.readline.chomp.split(COL_SEP)
+        raw_entries = pipe.read.split('&&&&&').map {|l| l.split(COL_SEP)}
+        entries = []
+        for raw_entry in raw_entries
+          entry = {}
+          header.length.times do |i|
+            entry[header[i]] = raw_entry[i]
+          end
+          entries << entry
+        end
+        return entries
+      end
+
+      # Turns the first line returned by mdb_export_table into a nice header
+      # hash
+      def turn_header_into_hash(lines)
+        header = lines.shift
+        header = header.split(COL_SEP)
+        header_hash = {}
+        i = 0
+        for name in header
+          header_hash[name] = i
+          i+=1
+        end
+        return header_hash
+      end
+
+      # Small helper function
+      def safe_float(x)
+        begin
+          Float(x)
+        rescue
+          0.0/0.0
+        end
+      end
+
+      # Inherit the baseline stuff.
+      inherit_parameters :base_line
+
+      attr_reader :current_database
+      param :read_mdb_file, :current_database, "readdb", "Read Database", 
+      {:type => :file, :filters => "Databases (*.mdb)"}, 
+      "Reads a database into memory"
+
+      # Reads the contents of a MDB file according to different defaults.
+      def read_mdb_file(file)
+        # First, make out the datasets from the file
+        if @current_database == file
+          return                  # We already read it !!
+        end
+        @current_database = file
+        
+        data_sets_properties =  mdb_table_to_hash(file, 'DataSetProperties')
+
+        prospective_data_sets = []
+        for set in data_sets_properties
+          prospective_data_sets << DataSet.new(set["DataSetName"], 
+                                               set["DataSetID"])
+        end
+
+        # We turn it into another array indexed on DataSetID for faster lookup
+        @data_sets_ids = []
+        for ds in prospective_data_sets
+          @data_sets_ids[ds.data_set_id.to_i] = ds
+        end
+        
+        # Now, we need to get data from the files
+        raise "@data_set_table_name has to be set" unless @data_set_table_name
+        raise "@data_set_y_col has to be set" unless @data_set_y_col
+        raise "@data_set_x_col has to be set" unless @data_set_x_col
+        raise "@data_set_z_col has to be set" unless @data_set_z_col
+        
+        l = mdb_export_table(file, @data_set_table_name, true)
+        h = turn_header_into_hash(l)
+        if h.key?(@data_set_x_col) and 
+            h.key?(@data_set_y_col) and 
+            h.key?(@data_set_z_col)
+          # We first sort the data respective to the first column
+          #         l.sort! do |a,b|
+          #           i_a = a[0,a.index(COL_SEP)].to_i
+          #           i_b = b[0,b.index(COL_SEP)].to_i
+          #           i_a <=> i_b
+          #         end
+          x_col = h[@data_set_x_col]
+          y_col = h[@data_set_y_col]
+          z_col = h[@data_set_z_col]
+          set_col = if @data_set_name_col
+                      h[@data_set_name_col]
+                    else 
+                      false
+                    end
+          id = h["DataSetID"]
+          
+
+          l.each do |l|
+            a = l.split(COL_SEP)
+            ds = @data_sets_ids[a[id].to_i]
+            x = safe_float(a[x_col])
+            y = safe_float(a[y_col])
+            z = safe_float(a[z_col])
+            if data_set_name_col
+              ds.add_point(x,y,z,a[set_col])
+            else
+              ds.add_point(x,y,z)
+            end
+          end
+          
+        else
+          raise "It looks like #{@data_set_x_col} or #{@data_set_y_col} is " +
+            "missing from the table #{@data_set_table_name} of file #{file}"
+        end
+
+        # Now, we populate the data_sets hash
+        for ds in prospective_data_sets 
+          @data_sets[ds.name] = ds
+        end
+      end
+
+      # Baseline stuff: we inherit it from the parents.
+
+
+      # This RE tells if a set looks like it might contain a subset.
+      # Slurps anything until the last @.
+      SUBSET_RE = /(.+)@(.+)/
+
+      
+      # An internal function saying how to make a X,Y dataset from
+      # a x,y,z dataset. Can depend on many things. We just output
+      # X and Y cols here. Better be redefined by children.
+      def internal_to_external(x,y,z)
+        return Function.new(x,y)
+      end
+
+      # Internal function to get the data corresponding to one set.
+      def get_data(set)
+        if set =~ SUBSET_RE
+          s = string_to_set($1)
+          raise "Set #{$1} is unkown" unless s
+          return internal_to_external(s.x_data($2), 
+                                      s.y_data($2),
+                                      s.z_data($2))
+        else
+          s = string_to_set(set)
+          raise "Set #{set} is unkown" unless s
+          return internal_to_external(s.x_data, s.y_data, s.z_data)
+        end
+      end
+
+      # This is called by the architecture to get the data. It splits
+      # the set name into filename@cols, reads the file if necessary and
+      # calls get_data
+      def query_xy_data(set)
+        data = get_data(set)
+        return Function.new(data.x.dup, data.y.dup)
+      end
+
+      # Transforms a string into a set. If the set starts with a #, it means
+      # we're directly interested in the number, not in the name. Can be a great
+      # deal useful, and much shorter...
+      def string_to_set(str)
+        if str =~ /^\#(\d+)$/
+          return @data_sets_ids[$1.to_i]
+        else
+          return @data_sets[str]
+        end
+      end
+
+      def expand_sets(set)
+        if s = string_to_set(set)
+          subs = s.subsets # we sort so that everything ids
+          # looking fine.
+          if subs.empty?
+            return [set]
+          else
+            return subs.collect {|s| "#{set}@#{s}"}
+          end
+        end
+        return [set]
+      end
+
+      # I think it is better not to take the cycles into account: they will
+      # hinder the display for no good reason.
+      def sets_available
+        return @data_sets.keys.sort
+      end
+
+    end
+
+    class MDBCyclicVoltammogram < MDBBackend
+
+      describe 'mdbcv', 'PAR PowerSuite MDB files, Cyclic Voltammetry', <<EOD
+Reads the MS Access files produced by the PAR electrochemistry suite,
+to extract cyclic voltammetry data.
+EOD
+      def initialize
+        super
+        @data_set_table_name = "CVDataPoints_280"
+        @data_set_x_col = "E"
+        @data_set_y_col = "I"
+        @data_set_z_col = "T"
+
+        @type = :cv
+        @neg = true
+      end
+
+      # We import parameters from the parent
+      inherit_parameters :read_mdb_file, :base_line
+
+      param_accessor :type, 'type', "Type", 
+      { :type => :list, :list => {
+          :cv => "I = f(E)",
+          :et => "E = f(t)",
+          :it => "I = f(t)"} }, 
+      "The kind of plot wanted"
+
+      param_accessor :neg, 'polarity', "Current polarity", 
+      { :type => :boolean } , "True inverses current polarity (on by default)"
+
+      # Returns the set wanted. (x = E, y = I, z = T);
+      def internal_to_external(x,y,z)
+        if @neg
+          y = y.neg
+        end
+        case @type
+        when :cv
+          return Function.new(x,y)
+        when :et
+          return Function.new(z.sub(z.min).mul!(86400),x)
+        when :it
+          return Function.new(z.sub(z.min).mul!(86400),y)
+        end
+      end
+
+    end
+
+    class MDBPStep < MDBCyclicVoltammogram
+
+      describe 'mdbps', 'PAR PowerSuite MDB files, Potential Steps', <<EOD
+Reads the MS Access files produced by the PAR electrochemistry suite,
+to extract potential step data.
+EOD
+
+      inherit_parameters :read_mdb_file, :base_line, :type, :neg
+
+      def initialize
+        super
+        @data_set_table_name = "CADataPoints_28"
+        @type = :it
+      end
+
+    end
+
+
+    class MDBEIS < MDBBackend
+
+      describe 'mdbeis', 'PAR PowerSuite MDB files, Impedance Spectroscopy', <<EOD
+Reads the MS Access files produced by the PAR electrochemistry suite,
+to extract impedance spectroscopy data.
+EOD
+      def initialize
+        super
+        @data_set_table_name = "ImpDataPoints_20"
+        @data_set_x_col = "Freq"
+        @data_set_y_col = "Zre"
+        @data_set_z_col = "Zim"
+
+        @type = :wzm
+      end
+
+      # We import parameters from the parent
+      inherit_parameters :read_mdb_file, :base_line
+
+      param_accessor :type, 'type', "Type", {:type => :list,
+        :list => {
+          :wzm => "|Z| = f(f)",
+          :wzi => "Zi = f(f)", 
+          :wzr => "Zr = f(f)",
+          :wphi => "Phi = f(f)",
+          :zrzi => "Zi = f(Zr)",
+          :yryi => "- Yi = f(Yr)",
+        }}, "The kind of plot wanted"
+
+      # Returns the set wanted. (x = Freq, y = Zre, z = Zim);
+      def internal_to_external(x,y,z)
+        case @type
+        when :wzm
+          return Function.new(x,y.pow(2).add!(z.pow(2)).sqrt)
+        when :wzi
+          return Function.new(x,z)
+        when :wzr
+          return Function.new(x,y)
+        when :zrzi
+          return Function.new(y,z)
+        when :wphi
+          return Function.new(x,z.div(y).atan!)
+        when :yryi
+          # We need to compute real and imaginary part of admittance
+          den = y**2 + z**2
+          return Function.new(y.div(den), 
+                              z.div(den))
+        end
+      end
+
+    end
+  end
+end
+
+