lazar 0.0.1

data/lib/descriptor.rb

@@ -0,0 +1,247 @@
+require 'digest/md5'
+ENV["JAVA_HOME"] ||= "/usr/lib/jvm/java-7-openjdk" 
+# TODO store descriptors in mongodb
+
+module OpenTox
+
+  module Algorithm 
+    
+    # Class for descriptor calculations
+    class Descriptor 
+      include OpenTox
+
+      JAVA_DIR = File.join(File.dirname(__FILE__),"..","java")
+      CDK_JAR = Dir[File.join(JAVA_DIR,"cdk-*jar")].last
+      JOELIB_JAR = File.join(JAVA_DIR,"joelib2.jar")
+      LOG4J_JAR = File.join(JAVA_DIR,"log4j.jar")
+      JMOL_JAR = File.join(JAVA_DIR,"Jmol.jar")
+
+      obexclude = ["cansmi","cansmiNS","formula","InChI","InChIKey","s","smarts","title"]
+      OBDESCRIPTORS = Hash[OpenBabel::OBDescriptor.list_as_string("descriptors").split("\n").collect do |d|
+        name,description = d.split(/\s+/,2)
+        ["Openbabel."+name,description] unless obexclude.include? name
+      end.compact.sort{|a,b| a[0] <=> b[0]}]
+
+      cdk_desc = YAML.load(`java -classpath #{CDK_JAR}:#{JAVA_DIR}  CdkDescriptorInfo`)
+      CDKDESCRIPTORS = Hash[cdk_desc.collect { |d| ["Cdk."+d[:java_class].split('.').last.sub(/Descriptor/,''), d[:description]] }.sort{|a,b| a[0] <=> b[0]}]
+      CDKDESCRIPTOR_VALUES = cdk_desc.collect { |d| prefix="Cdk."+d[:java_class].split('.').last.sub(/Descriptor/,''); d[:names].collect{ |name| prefix+"."+name } }.flatten
+
+      # exclude Hashcode (not a physchem property) and GlobalTopologicalChargeIndex (Joelib bug)
+      joelibexclude = ["MoleculeHashcode","GlobalTopologicalChargeIndex"]
+      # strip Joelib messages from stdout
+      JOELIBDESCRIPTORS = Hash[YAML.load(`java -classpath #{JOELIB_JAR}:#{LOG4J_JAR}:#{JAVA_DIR}  JoelibDescriptorInfo | sed '0,/---/d'`).collect do |d|
+        name = d[:java_class].sub(/^joelib2.feature.types./,'')
+        # impossible to obtain meaningful descriptions from JOELIb, see java/JoelibDescriptors.java
+        ["Joelib."+name, "no description available"] unless joelibexclude.include? name
+      end.compact.sort{|a,b| a[0] <=> b[0]}] 
+
+      DESCRIPTORS = OBDESCRIPTORS.merge(CDKDESCRIPTORS.merge(JOELIBDESCRIPTORS))
+      DESCRIPTOR_VALUES = OBDESCRIPTORS.keys + CDKDESCRIPTOR_VALUES + JOELIBDESCRIPTORS.keys
+
+      require_relative "unique_descriptors.rb"
+
+      # Description of available descriptors
+      def self.description descriptor
+        lib = descriptor.split('.').first
+        case lib
+        when "Openbabel"
+          OBDESCRIPTORS[descriptor]
+        when "Cdk"
+          name = descriptor.split('.')[0..-2].join('.')
+          CDKDESCRIPTORS[name]
+        when "Joelib"
+          JOELIBDESCRIPTORS[descriptor]
+        when "lookup"
+          "Read feature values from a dataset"
+        end
+      end
+
+      # Match an array of smarts features 
+      def self.smarts_match compounds, smarts_features, count=false
+        bad_request_error "Compounds for smarts_match are empty" unless compounds
+        bad_request_error "Smarts features for smarts_match are empty" unless smarts_features
+        parse compounds
+        @count = count
+        obconversion = OpenBabel::OBConversion.new
+        obmol = OpenBabel::OBMol.new
+        obconversion.set_in_format('smi')
+        smarts_pattern = OpenBabel::OBSmartsPattern.new
+        smarts_features = [smarts_features] if smarts_features.is_a?(Feature)
+        @smarts = smarts_features.collect{|f| f.smarts}
+        @physchem_descriptors = nil
+        @data_entries = Array.new(@compounds.size){Array.new(@smarts.size,false)}
+        @compounds.each_with_index do |compound,c|
+          obconversion.read_string(obmol,compound.smiles)
+          @smarts.each_with_index do |smart,s|
+            smarts_pattern.init(smart)
+            if smarts_pattern.match(obmol)
+              count ? value = smarts_pattern.get_map_list.to_a.size : value = 1
+            else
+              value = 0 
+            end
+            @data_entries[c][s] = value
+          end
+        end
+        serialize 
+      end
+
+      # Count matches of an array with smarts features 
+      def self.smarts_count compounds, smarts
+        # TODO: non-overlapping matches?
+        smarts_match compounds,smarts,true
+      end
+
+      # Calculate physchem descriptors
+      # @param [OpenTox::Compound,Array,OpenTox::Dataset] input object, either a compound, an array of compounds or a dataset
+      def self.physchem compounds, descriptors=UNIQUEDESCRIPTORS
+        parse compounds
+        @data_entries = Array.new(@compounds.size){[]}
+        @descriptors = descriptors
+        @smarts = nil
+        @physchem_descriptors = [] # CDK may return more than one result per descriptor, they are stored as separate features
+        des = {}
+        @descriptors.each do |d|
+          lib, descriptor = d.split(".",2)
+          lib = lib.downcase.to_sym
+          des[lib] ||= []
+          des[lib] << descriptor
+        end
+        des.each do |lib,descriptors|
+          send(lib, descriptors)
+        end
+        serialize
+      end
+
+      def self.openbabel descriptors
+        $logger.debug "compute #{descriptors.size} openbabel descriptors for #{@compounds.size} compounds"
+        obdescriptors = descriptors.collect{|d| OpenBabel::OBDescriptor.find_type d}
+        obmol = OpenBabel::OBMol.new
+        obconversion = OpenBabel::OBConversion.new
+        obconversion.set_in_format 'smi'
+        last_feature_idx = @physchem_descriptors.size
+        @compounds.each_with_index do |compound,c|
+          obconversion.read_string obmol, compound.smiles
+          obdescriptors.each_with_index do |descriptor,d|
+            @data_entries[c][d+last_feature_idx] = fix_value(descriptor.predict(obmol))
+          end
+        end
+        @physchem_descriptors += descriptors.collect{|d| "Openbabel.#{d}"}
+      end
+
+      def self.java_descriptors descriptors, lib
+        $logger.debug "compute #{descriptors.size} cdk descriptors for #{@compounds.size} compounds"
+        sdf = sdf_3d 
+        # use java system call (rjb blocks within tasks)
+        # use Tempfiles to avoid "Argument list too long" error 
+        case lib
+        when "cdk"
+          run_cmd "java -classpath #{CDK_JAR}:#{JAVA_DIR}  CdkDescriptors #{sdf} #{descriptors.join(" ")}"
+        when "joelib"
+          run_cmd "java -classpath #{JOELIB_JAR}:#{JMOL_JAR}:#{LOG4J_JAR}:#{JAVA_DIR}  JoelibDescriptors  #{sdf} #{descriptors.join(' ')}"
+        end
+        last_feature_idx = @physchem_descriptors.size
+        YAML.load_file("#{sdf}#{lib}.yaml").each_with_index do |calculation,i|
+          # TODO create warnings
+          #$logger.error "Descriptor calculation failed for compound #{@compounds[i].inchi}." if calculation.empty?
+          # CDK Descriptors may calculate multiple values, they are stored in separate features
+          @physchem_descriptors += calculation.keys if i == 0
+          calculation.keys.each_with_index do |name,j|
+            @data_entries[i][j+last_feature_idx] = fix_value(calculation[name])
+          end
+        end
+        FileUtils.rm "#{sdf}#{lib}.yaml"
+      end
+
+      def self.cdk descriptors
+        java_descriptors descriptors, "cdk"
+      end
+
+      def self.joelib descriptors
+        java_descriptors descriptors, "joelib"
+      end
+
+      def self.lookup compounds, features, dataset
+        parse compounds
+        fingerprint = []
+        compounds.each do |compound|
+          fingerprint << []
+          features.each do |feature|
+          end
+        end
+      end
+
+      def self.run_cmd cmd
+        cmd = "#{cmd} 2>&1"
+        $logger.debug "running external cmd: '#{cmd}'"
+        p = IO.popen(cmd) do |io|
+          while line = io.gets
+            $logger.debug "> #{line.chomp}"
+          end
+          io.close
+          raise "external cmd failed '#{cmd}' (see log file for error msg)" unless $?.to_i == 0
+        end
+      end
+
+      def self.sdf_3d 
+        # TODO check if 3d sdfs are stored in GridFS
+        sdf = ""
+        @compounds.each do |compound|
+          sdf << compound.sdf
+        end
+        sdf_file = "/tmp/#{SecureRandom.uuid}.sdf"
+        File.open(sdf_file,"w+"){|f| f.print sdf}
+        sdf_file
+      end
+
+      def self.parse compounds
+        @input_class = compounds.class.to_s
+        case @input_class
+        when "OpenTox::Compound"
+          @compounds = [compounds]
+        when "Array"
+          @compounds = compounds
+        when "OpenTox::Dataset"
+          @compounds = compounds.compounds
+        else
+          bad_request_error "Cannot calculate descriptors for #{compounds.class} objects."
+        end
+      end
+
+      def self.serialize
+        @data_entries.collect!{|de| de.collect{|v| v.round(5) unless v.nil?}}
+        case @input_class
+        when "OpenTox::Compound"
+          @data_entries.first
+        when "Array"
+          @data_entries
+        when "OpenTox::Dataset"
+          dataset = OpenTox::DescriptorDataset.new(:compound_ids => @compounds.collect{|c| c.id})
+          if @smarts
+            dataset.feature_ids = @smarts.collect{|smart| Smarts.find_or_create_by(:smarts => smart).id}
+            @count ? algo = "count" : algo = "match"
+            dataset.feature_calculation_algorithm = "#{self}.smarts_#{algo}"
+            
+          elsif @physchem_descriptors
+            dataset.feature_ids = @physchem_descriptors.collect{|d| PhysChemDescriptor.find_or_create_by(:name => d, :creator => __FILE__).id}
+            dataset.data_entries = @data_entries
+            dataset.feature_calculation_algorithm = "#{self}.physchem"
+            #TODO params?
+          end
+          dataset.save_all
+          dataset
+        end
+      end
+
+      def self.fix_value val
+        val = val.first if val.is_a? Array and val.size == 1
+        val = nil if val == "NaN"
+        if val.numeric?
+          val = Float(val)
+          val = nil if val.nan? or val.infinite?
+        end
+        val
+      end
+      private_class_method :sdf_3d, :fix_value, :parse, :run_cmd, :serialize
+    end
+  end
+end

data/lib/error.rb

@@ -0,0 +1,66 @@
+module OpenToxError
+  attr_accessor :http_code, :message, :cause
+  def initialize message=nil
+    message = message.to_s.gsub(/\A"|"\Z/, '') if message # remove quotes
+    super message
+    @http_code ||= 500
+    @message = message.to_s
+    @cause = cut_backtrace(caller)
+    $logger.error("\n"+JSON.pretty_generate({
+      :http_code => @http_code,
+      :message => @message,
+      :cause => @cause
+    })) 
+  end
+  
+  def cut_backtrace(trace)
+    if trace.is_a?(Array)
+      cut_index = trace.find_index{|line| line.match(/sinatra|minitest/)}
+      cut_index ||= trace.size
+      cut_index -= 1
+      cut_index = trace.size-1 if cut_index < 0
+      trace[0..cut_index]
+    else
+      trace
+    end
+  end
+
+end
+
+class RuntimeError
+  include OpenToxError
+end
+
+# clutters log file with library errors 
+#class NoMethodError
+  #include OpenToxError
+#end
+
+module OpenTox
+
+  class Error < RuntimeError
+    include OpenToxError
+    
+    def initialize(code, message=nil)
+      @http_code = code
+      super message
+    end
+  end
+
+  # OpenTox errors
+  RestClientWrapper.known_errors.each do |error|
+    # create error classes 
+    c = Class.new Error do
+      define_method :initialize do |message=nil|
+        super error[:code], message
+      end
+    end
+    OpenTox.const_set error[:class],c
+    
+    # define global methods for raising errors, eg. bad_request_error
+    Object.send(:define_method, error[:method]) do |message,uri=nil,cause=nil|
+      raise c.new(message)
+    end
+  end
+  
+end

data/lib/feature.rb

@@ -0,0 +1,97 @@
+module OpenTox
+
+  # Basic feature class
+  class Feature
+    field :name, as: :title, type: String
+    field :nominal, type: Boolean
+    field :numeric, type: Boolean
+    field :measured, type: Boolean
+  end
+
+  # Feature for categorical variables
+  class NominalFeature < Feature
+    # TODO check if accept_values are still needed 
+    field :accept_values, type: Array
+    def initialize params
+      super params
+      nominal = true
+    end
+  end
+
+  # Feature for quantitative variables
+  class NumericFeature < Feature
+    def initialize params
+      super params
+      numeric = true
+    end
+  end
+
+  # Feature for SMARTS fragments
+  class Smarts < NominalFeature
+    field :smarts, type: String 
+    def self.from_smarts smarts
+      self.find_or_create_by :smarts => smarts
+    end
+  end
+
+  # Feature for supervised fragments from Fminer algorithm
+  class FminerSmarts < Smarts
+    field :p_value, type: Float
+    # TODO check if effect is used
+    field :effect, type: String
+    field :dataset_id 
+  end
+
+  # Feature for database fingerprints
+  # needs count for efficient retrieval (see compound.rb)
+  class FingerprintSmarts < Smarts
+    field :count, type: Integer
+    def self.fingerprint
+      @@fp4 ||= OpenTox::FingerprintSmarts.all
+      unless @@fp4.size == 306
+        @@fp4 = []
+        # OpenBabel FP4 fingerprints
+        # OpenBabel http://open-babel.readthedocs.org/en/latest/Fingerprints/intro.html
+        # TODO investigate other types of fingerprints (MACCS)
+        # OpenBabel http://open-babel.readthedocs.org/en/latest/Fingerprints/intro.html
+        # http://www.dalkescientific.com/writings/diary/archive/2008/06/26/fingerprint_background.html
+        # OpenBabel MNA http://openbabel.org/docs/dev/FileFormats/Multilevel_Neighborhoods_of_Atoms_(MNA).html#multilevel-neighborhoods-of-atoms-mna
+        # Morgan ECFP, FCFP
+        # http://cdk.github.io/cdk/1.5/docs/api/org/openscience/cdk/fingerprint/CircularFingerprinter.html
+        # http://www.rdkit.org/docs/GettingStartedInPython.html
+        # Chemfp
+        # https://chemfp.readthedocs.org/en/latest/using-tools.html
+        # CACTVS/PubChem
+
+        File.open(File.join(File.dirname(__FILE__),"SMARTS_InteLigand.txt")).each do |l| 
+          l.strip!
+          unless l.empty? or l.match /^#/
+            name,smarts = l.split(': ')
+            @@fp4 << OpenTox::FingerprintSmarts.find_or_create_by(:name => name, :smarts => smarts) unless smarts.nil?
+          end
+        end
+      end
+      @@fp4
+    end
+  end
+
+  # Feature for physico-chemical descriptors
+  class PhysChemDescriptor < NumericFeature
+    field :algorithm, type: String, default: "OpenTox::Algorithm::Descriptor.physchem"
+    field :parameters, type: Hash
+    field :creator, type: String
+  end
+
+  # Feature for categorical bioassay results
+  class NominalBioAssay < NominalFeature
+    # TODO: needed? move to dataset?
+    field :description, type: String
+  end
+
+  # Feature for quantitative bioassay results
+  class NumericBioAssay < NumericFeature
+    # TODO: needed? move to dataset?
+    field :description, type: String
+  end
+
+end

data/lib/lazar-model.rb

@@ -0,0 +1,170 @@
+module OpenTox
+
+  module Model
+
+    class Lazar 
+      include OpenTox
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      store_in collection: "models"
+
+      field :title, type: String
+      field :creator, type: String, default: __FILE__
+      # datasets
+      field :training_dataset_id, type: BSON::ObjectId
+      # algorithms
+      field :prediction_algorithm, type: String
+      field :neighbor_algorithm, type: String
+      field :neighbor_algorithm_parameters, type: Hash
+      # prediction feature
+      field :prediction_feature_id, type: BSON::ObjectId
+
+      attr_accessor :prediction_dataset
+      attr_accessor :training_dataset
+
+      # Create a lazar model from a training_dataset and a feature_dataset
+      # @param [OpenTox::Dataset] training_dataset
+      # @return [OpenTox::Model::Lazar] Regression or classification model
+      def self.create training_dataset
+
+        bad_request_error "More than one prediction feature found in training_dataset #{training_dataset.id}" unless training_dataset.features.size == 1
+
+        # TODO document convention
+        prediction_feature = training_dataset.features.first
+        prediction_feature.nominal ?  lazar = OpenTox::Model::LazarClassification.new : lazar = OpenTox::Model::LazarRegression.new
+        lazar.training_dataset_id = training_dataset.id
+        lazar.prediction_feature_id = prediction_feature.id
+        lazar.title = prediction_feature.title 
+
+        lazar.save
+        lazar
+      end
+
+      def predict object
+
+        t = Time.now
+        at = Time.now
+
+        training_dataset = Dataset.find training_dataset_id
+        prediction_feature = Feature.find prediction_feature_id
+
+        # parse data
+        compounds = []
+        case object.class.to_s
+        when "OpenTox::Compound"
+          compounds = [object] 
+        when "Array"
+          compounds = object
+        when "OpenTox::Dataset"
+          compounds = object.compounds
+        else 
+          bad_request_error "Please provide a OpenTox::Compound an Array of OpenTox::Compounds or an OpenTox::Dataset as parameter."
+        end
+
+        # make predictions
+        predictions = []
+        neighbors = []
+        compounds.each_with_index do |compound,c|
+          t = Time.new
+          database_activities = training_dataset.values(compound,prediction_feature)
+          if database_activities and !database_activities.empty?
+            database_activities = database_activities.first if database_activities.size == 1
+            predictions << {:compound => compound, :value => database_activities, :confidence => "measured", :warning => "Compound #{compound.smiles} occurs in training dataset with activity '#{database_activities}'."}
+            next
+          end
+          neighbors = Algorithm.run(neighbor_algorithm, compound, neighbor_algorithm_parameters)
+          # add activities
+          # TODO: improve efficiency, takes 3 times longer than previous version
+          neighbors.collect! do |n|
+            rows = training_dataset.compound_ids.each_index.select{|i| training_dataset.compound_ids[i] == n.first}
+            acts = rows.collect{|row| training_dataset.data_entries[row][0]}.compact
+            acts.empty? ? nil : n << acts
+          end
+          neighbors.compact! # remove neighbors without training activities
+          predictions << Algorithm.run(prediction_algorithm, neighbors)
+        end 
+
+        # serialize result
+        case object.class.to_s
+        when "OpenTox::Compound"
+          prediction = predictions.first
+          prediction[:neighbors] = neighbors.sort{|a,b| b[1] <=> a[1]} # sort according to similarity
+          return prediction
+        when "Array"
+          return predictions
+        when "OpenTox::Dataset"
+          # prepare prediction dataset
+          prediction_dataset = LazarPrediction.new(
+            :title => "Lazar prediction for #{prediction_feature.title}",
+            :creator =>  __FILE__,
+            :prediction_feature_id => prediction_feature.id
+
+          )
+          confidence_feature = OpenTox::NumericFeature.find_or_create_by( "title" => "Prediction confidence" )
+          # TODO move into warnings field
+          warning_feature = OpenTox::NominalFeature.find_or_create_by("title" => "Warnings")
+          prediction_dataset.features = [ prediction_feature, confidence_feature, warning_feature ]
+          prediction_dataset.compounds = compounds
+          prediction_dataset.data_entries = predictions.collect{|p| [p[:value], p[:confidence], p[:warning]]}
+          prediction_dataset.save_all
+          return prediction_dataset
+        end
+
+      end
+      
+      def training_activities
+        i = training_dataset.feature_ids.index prediction_feature_id
+        training_dataset.data_entries.collect{|de| de[i]}
+      end
+
+    end
+
+    class LazarClassification < Lazar
+      def initialize
+        super
+        self.prediction_algorithm = "OpenTox::Algorithm::Classification.weighted_majority_vote"
+        self.neighbor_algorithm = "OpenTox::Algorithm::Neighbor.fingerprint_similarity"
+        self.neighbor_algorithm_parameters = {:min_sim => 0.7}
+      end
+    end
+
+    class LazarFminerClassification < LazarClassification
+
+      def self.create training_dataset
+        model = super(training_dataset)
+        model.update "_type" => self.to_s # adjust class
+        model = self.find model.id # adjust class
+        model.neighbor_algorithm = "OpenTox::Algorithm::Neighbor.fminer_similarity"
+        model.neighbor_algorithm_parameters = {
+          :feature_calculation_algorithm => "OpenTox::Algorithm::Descriptor.smarts_match",
+          :feature_dataset_id => Algorithm::Fminer.bbrc(training_dataset).id,
+          :min_sim => 0.3
+        }
+        model.save
+        model
+      end
+    end
+
+    class LazarRegression < Lazar
+
+      def initialize
+        super
+        self.neighbor_algorithm = "OpenTox::Algorithm::Neighbor.fingerprint_similarity"
+        self.prediction_algorithm = "OpenTox::Algorithm::Regression.weighted_average" 
+        self.neighbor_algorithm_parameters = {:min_sim => 0.7}
+      end
+
+    end
+
+    class PredictionModel < Lazar
+      field :category, type: String
+      field :endpoint, type: String
+      field :unit, type: String
+      field :model_id, type: BSON::ObjectId
+      field :crossvalidation_id, type: BSON::ObjectId
+    end
+
+  end
+
+end
+

data/lib/lazar.rb

@@ -0,0 +1,69 @@
+require 'rubygems'
+require "bundler/setup"
+require "rest-client"
+require 'yaml'
+require 'json'
+require 'logger'
+require 'mongoid'
+require 'rserve'
+require "nokogiri"
+require "base64"
+
+
+# Mongo setup
+# TODO retrieve correct environment from Rack/Sinatra
+ENV["MONGOID_ENV"] ||= "development"
+# TODO remove config files, change default via ENV or directly in Mongoid class
+Mongoid.load!("#{File.expand_path(File.join(File.dirname(__FILE__),'..','mongoid.yml'))}")
+# TODO get Mongo::Client from Mongoid
+$mongo = Mongo::Client.new('mongodb://127.0.0.1:27017/opentox')
+# TODO same for GridFS
+$gridfs = $mongo.database.fs
+
+# R setup
+R = Rserve::Connection.new
+
+# Logger setup
+$logger = Logger.new STDOUT # STDERR did not work on my development machine (CH)
+$logger.level = Logger::DEBUG
+Mongo::Logger.logger = $logger
+Mongo::Logger.level = Logger::WARN 
+#Mongoid.logger = $logger
+
+# Require sub-Repositories
+require_relative '../libfminer/libbbrc/bbrc' # include before openbabel
+require_relative '../libfminer/liblast/last' # 
+require_relative '../last-utils/lu.rb'
+require_relative '../openbabel/lib/openbabel'
+
+# Fminer environment variables
+ENV['FMINER_SMARTS'] = 'true'
+ENV['FMINER_NO_AROMATIC'] = 'true'
+ENV['FMINER_PVALUES'] = 'true'
+ENV['FMINER_SILENT'] = 'true'
+ENV['FMINER_NR_HITS'] = 'true'
+
+# OpenTox classes and includes
+CLASSES = ["Feature","Compound","Dataset","Validation","CrossValidation"]# Algorithm and Models are modules
+
+[ # be aware of the require sequence as it affects class/method overwrites
+  "overwrite.rb",
+  "rest-client-wrapper.rb", 
+  "error.rb",
+  "opentox.rb",
+  "feature.rb",
+  "compound.rb",
+  "dataset.rb",
+  "descriptor.rb",
+  "algorithm.rb",
+  "descriptor.rb",
+  "bbrc.rb",
+  "lazar-model.rb",
+  "similarity.rb",
+  "neighbor.rb",
+  "classification.rb",
+  "regression.rb",
+  "validation.rb",
+  "crossvalidation.rb",
+].each{ |f| require_relative f }
+

data/lib/neighbor.rb

@@ -0,0 +1,25 @@
+module OpenTox
+  module Algorithm
+    class Neighbor
+
+      def self.fingerprint_similarity compound, params={}
+        compound.neighbors params[:min_sim]
+      end
+
+      def self.fminer_similarity compound, params
+        feature_dataset = Dataset.find params[:feature_dataset_id]
+        query_fingerprint = Algorithm::Descriptor.smarts_match(compound, feature_dataset.features)
+        neighbors = []
+
+        # find neighbors
+        feature_dataset.data_entries.each_with_index do |fingerprint, i|
+          sim = Algorithm::Similarity.tanimoto fingerprint, query_fingerprint
+          if sim > params[:min_sim]
+            neighbors << [feature_dataset.compound_ids[i],sim] # use compound_ids, instantiation of Compounds is too time consuming
+          end
+        end
+        neighbors
+      end
+    end
+  end
+end

data/lib/opentox.rb

@@ -0,0 +1,22 @@
+module OpenTox
+
+  # Ruby interface
+
+  # create default OpenTox classes (defined in opentox-client.rb)
+  # provides Mongoid's query and persistence methods
+  # http://mongoid.org/en/mongoid/docs/persistence.html
+  # http://mongoid.org/en/mongoid/docs/querying.html
+  CLASSES.each do |klass|
+    c = Class.new do
+      include OpenTox
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      store_in collection: klass.downcase.pluralize
+      field :title, as: :name,  type: String
+
+    end
+    OpenTox.const_set klass,c
+  end
+
+end
+