opentox-ruby 2.0.1 → 2.1.0

data/lib/serializer.rb

@@ -17,6 +17,7 @@ module OpenTox
           # this should come from opentox.owl
           OT.Compound => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.Feature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.Model => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.NominalFeature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.NumericFeature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.StringFeature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
@@ -27,6 +28,8 @@ module OpenTox
           OT.Parameter => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OT.Task => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
           OTA.PatternMiningSupervised => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OTA.ClassificationLazySingleTarget => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OTA.RegressionLazySingleTarget => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
 
           #classes for validation
           OT.Validation => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
@@ -45,6 +48,10 @@ module OpenTox
           OT.values => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
           OT.algorithm => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
           OT.parameters => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.featureDataset => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.dependentVariables => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.predictedVariables => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.paramValue => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
 
           #object props for validation#           
           OT.model => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
@@ -103,6 +110,7 @@ module OpenTox
           OT.precision => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
           OT.areaUnderRoc => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
           OT.weightedAreaUnderRoc => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.weightedAccuracy => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
           OT.fMeasure => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
           OT.percentIncorrect => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
           OT.validationType => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
@@ -126,7 +134,7 @@ module OpenTox
           OT.hasSource => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
           OT.value => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
           OT.paramScope => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
-          OT.paramValue => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
+          #OT.paramValue => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
         }
 
         @data_entries = {}
@@ -157,23 +165,16 @@ module OpenTox
       # Add a dataset
       # @param [String] uri Dataset URI
       def add_dataset(dataset)
-
         @dataset = dataset.uri
-
         @object[dataset.uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Dataset }] }
-
         add_metadata dataset.uri, dataset.metadata
-
         dataset.compounds.each { |compound| add_compound compound }
-        
         dataset.features.each { |feature,metadata| add_feature feature,metadata }
-        
         dataset.data_entries.each do |compound,entry|
           entry.each do |feature,values|
             values.each { |value| add_data_entry compound,feature,value }
           end
         end
-
       end
 
       # Add a algorithm
@@ -188,6 +189,14 @@ module OpenTox
       def add_model(uri,metadata)
         @object[uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Model }] }
         add_metadata uri, metadata
+        @object[metadata[OT.featureDataset]] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Dataset }] }
+        @object[metadata[OT.trainingDataset]] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Dataset }] }
+        @object[metadata[OT.dependentVariables]] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Feature }] }
+        metadata[OT.predictedVariables].each{|feature| @object[feature] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Feature }]}} #unless metadata[OT.predictedVariables].nil?
+        # TODO: add algorithms from parameters
+        @object["http://ot-dev.in-silico.ch/algorithm/fminer/bbrc"] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Algorithm }] }
+        @object["http://ot-dev.in-silico.ch/algorithm/fminer/last"] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Algorithm }] }
+        @object["http://ot-dev.in-silico.ch/algorithm/lazar"] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Algorithm }] }
       end
 
       # Add a task
@@ -272,7 +281,7 @@ module OpenTox
                 @object[genid][name] = [{"type" => type(entry), "value" => entry }]
               end
             end
-          elsif v.is_a? Array and u == RDF.type
+          elsif v.is_a? Array #and u == RDF.type
             @object[uri] = {} unless @object[uri]
             v.each do |value|
               @object[uri][u] = [] unless @object[uri][u]
@@ -354,7 +363,8 @@ module OpenTox
       # @return [text/plain] Object OWL-DL in RDF/XML format
       def to_rdfxml
         Tempfile.open("owl-serializer"){|f| f.write(self.to_ntriples); @path = f.path}
-        `rapper -i ntriples -f 'xmlns:ot="#{OT.uri}"' -f 'xmlns:dc="#{DC.uri}"' -f 'xmlns:rdf="#{RDF.uri}"' -f 'xmlns:owl="#{OWL.uri}"' -o rdfxml #{@path} 2>/dev/null`
+        # TODO: add base uri for ist services
+        `rapper -i ntriples -f 'xmlns:ot="#{OT.uri}"' -f 'xmlns:ota="#{OTA.uri}"' -f 'xmlns:dc="#{DC.uri}"' -f 'xmlns:rdf="#{RDF.uri}"' -f 'xmlns:owl="#{OWL.uri}"' -o rdfxml #{@path} 2>/dev/null`
       end
 
       # Convert to JSON as specified in http://n2.talis.com/wiki/RDF_JSON_Specification
@@ -373,6 +383,8 @@ module OpenTox
           XSD.boolean
         elsif value.is_a? Float
           XSD.float
+        elsif value.is_a? Integer
+          XSD.integer
         else
           XSD.string
         end
@@ -383,6 +395,8 @@ module OpenTox
           datatype = OT.NominalFeature
         elsif value.is_a? Float
           datatype = OT.NumericFeature
+        elsif value.is_a? Integer
+          datatype = OT.NumericFeature
         else
           datatype = OT.StringFeature
         end

data/lib/task.rb

@@ -38,6 +38,7 @@ module OpenTox
       task = Task.new(task_uri.chomp)
 
       # measure current memory consumption
+=begin
       memory = `free -m|sed -n '2p'`.split
       free_memory = memory[3].to_i + memory[6].to_i # include cache
       if free_memory < 20 # require at least 200 M free memory
@@ -56,6 +57,7 @@ module OpenTox
       #  return task
       #  #raise "Server too busy to start a new task"
       #end
+=end
 
       task_pid = Spork.spork(:logger => LOGGER) do
         LOGGER.debug "Task #{task.uri} started #{Time.now}"
@@ -167,6 +169,10 @@ module OpenTox
       @metadata[OT.hasStatus] == 'Running'
     end
 
+    def queued?
+      @metadata[OT.hasStatus] == 'Queued'
+    end
+
     def completed?
       @metadata[OT.hasStatus] == 'Completed'
     end
@@ -244,7 +250,7 @@ module OpenTox
       
       load_metadata # for extremely fast tasks
       check_state
-      while self.running?
+      while self.running? or self.queued?
         sleep dur
         load_metadata 
         # if another (sub)task is waiting for self, set progress accordingly 
@@ -284,9 +290,10 @@ module OpenTox
         raise "illegal task state, task is completed, resultURI is no URI: '"+@metadata[OT.resultURI].to_s+
             "'" unless @metadata[OT.resultURI] and @metadata[OT.resultURI].to_s.uri? if completed?
         if @http_code == 202
-          raise "#{@uri}: illegal task state, code is 202, but hasStatus is not Running: '"+@metadata[OT.hasStatus]+"'" unless running?
+          raise "#{@uri}: illegal task state, code is 202, but hasStatus is not Running or Queued: '"+@metadata[OT.hasStatus]+"'" unless running? or queued?
         elsif @http_code == 201
-          raise "#{@uri}: illegal task state, code is 201, but hasStatus is not Completed: '"+@metadata[OT.hasStatus]+"'" unless completed?
+          # ignore hasStatus
+          # raise "#{@uri}: illegal task state, code is 201, but hasStatus is not Completed: '"+@metadata[OT.hasStatus]+"'" unless completed?
           raise "#{@uri}: illegal task state, code is 201, resultURI is no task-URI: '"+@metadata[OT.resultURI].to_s+
               "'" unless @metadata[OT.resultURI] and @metadata[OT.resultURI].to_s.uri?
         end

data/lib/to-html.rb

@@ -1,12 +1,12 @@
 
-OT_LOGO = "http://opentox.informatik.uni-freiburg.de/ot-logo.png"
+OT_LOGO = File.join(CONFIG[:services]["opentox-validation"],"resources/ot-logo.png")
 
 class String
   
   # encloses URI in text with with link tag
   # @return [String] new text with marked links
   def link_urls
-    self.gsub(/(?i)http(s?):\/\/[^\r\n\s']*/, '<a href=\0>\0</a>')
+    self.gsub(/(?i)http(s?):\/\/[^\r\n\s']*/, '<a href="\0">\0</a>')
   end
 end
 
@@ -15,98 +15,123 @@ module OpenTox
   # produces a html page for making web services browser friendly
   # format of text (=string params) is preserved (e.g. line breaks)
   # urls are marked as links
-  # @example post params:
-  # [ [ [:mandatory_param_1], [:mandatory_param_2], [:optional_param,"default_value"] ],
-  #   [ [:alteranative_mandatory_param_1], [:alteranative_mandatory_param_2] ]
-  # ] 
+  #
   # @param [String] text this is the actual content, 
   # @param [optional,String] related_links info on related resources
   # @param [optional,String] description general info
-  # @param [optional,Array] post_params, array of arrays containing info on POST operation, see example
+  # @param [optional,Array] post_command, infos for the post operation, object defined below
   # @return [String] html page
-  def self.text_to_html( text, subjectid=nil, related_links=nil, description=nil, post_params=nil  )
+  def self.text_to_html( text, subjectid=nil, related_links=nil, description=nil, post_command=nil  )
     
     # TODO add title as parameter
     title = nil #$sinatra.url_for($sinatra.request.env['PATH_INFO'], :full) if $sinatra
     html = "<html>"
     html += "<title>"+title+"</title>" if title
-    html += "<img src="+OT_LOGO+"><body>"
+    html += "<img src=\""+OT_LOGO+"\"><\/img><body>"
       
     if AA_SERVER
       user = OpenTox::Authorization.get_user(subjectid) if subjectid
       html +=  "<pre><p align=\"right\">"
       unless user
-        html += "You are currently not logged in to "+$url_provider.url_for("",:full)+
-          ", <a href="+$url_provider.url_for("/login",:full)+">login</a>"
+        html += "You are currently not signed in to "+$url_provider.url_for("",:full)+
+          ", <a href="+$url_provider.url_for("/sign_in",:full)+">sign in</a>"
       else
-        html += "You are logged in as '#{user}' to "+$url_provider.url_for("",:full)+
-          ", <a href="+$url_provider.url_for("/logout",:full)+">logout</a>"
+        html += "You are signed in as '#{user}' to "+$url_provider.url_for("",:full)+
+          ", <a href="+$url_provider.url_for("/sign_out",:full)+">sign out</a>"
       end
       html += "  </p></pre>"
     end 
    
     html += "<h3>Description</h3><pre><p>"+description.link_urls+"</p></pre>" if description
     html += "<h3>Related links</h3><pre><p>"+related_links.link_urls+"</p></pre>" if related_links
-    if post_params
-      html += "<h3>POST parameters</h3>"
-      count = 0
-      post_params.each do |p|
-        html += "<pre><p>alternatively:</p></pre>" if count > 0
-        html += "<pre><p><table><thead><tr><th>param</th><th>default_value</th></tr></thead>"
-        p.each do |k,v|
-          html += "<tr><th>"+k.to_s+"</th><th>"+(v!=nil ? v.to_s : "<i>mandatory</i>")+"</th></tr>"
-        end
-        html += "</table></p></pre>"
-        count += 1
-      end
+    if post_command
+      raise "not a post command" unless post_command.is_a?(OpenTox::PostCommand)
+      html += "<h3>POST command</h3>"
+      html += post_command.to_html
     end
-    html += "<h3>Content</h3>" if description || related_links
+    html += "<h3>Content</h3>" if description || related_links || post_command
     html += "<pre><p style=\"padding:15px; border:10px solid \#5D308A\">"
     html += text.link_urls
-    html += "</p></pre></body><html>"
+    html += "</p></pre></body></html>"
     html
   end
   
-  def self.login( msg=nil )
+  def self.sign_in( msg=nil )
     html = "<html><title>Login</title><img src="+OT_LOGO+"><body>"
-    html += "<form method='POST' action='"+$url_provider.url_for("/login",:full)+"'>"
+    html += "<form method='POST' action='"+$url_provider.url_for("/sign_in",:full)+"'>"
     html += "<pre><p style=\"padding:15px; border:10px solid \#5D308A\">"
     html += msg+"\n\n" if msg
-    html += "Please login to "+$url_provider.url_for("",:full)+"\n\n"
+    html += "Please sign in to "+$url_provider.url_for("",:full)+"\n\n"
     html += "<table border=0>"
     html += "<tr><td>user:</td><td><input type='text' name='user' size='15' /></td></tr>"+
           "<tr><td>password:</td><td><input type='password' name='password' size='15' /></td></tr>"+
           #"<input type=hidden name=back_to value="+back_to.to_s+">"+
-          "<tr><td><input type='submit' value='Login' /></td></tr>"
-    html += "</table></p></pre></form></body><html>"
+          "<tr><td><input type='submit' value='Sign in' /></td></tr>"
+    html += "</table></p></pre></form></body></html>"
     html
   end
+  
+  class PostAttribute
+    attr_accessor :name, :is_mandatory, :default, :description
+    
+    def initialize(name, is_mandatory=true, default=nil, description=nil)
+      @name = name
+      @is_mandatory = is_mandatory
+      @default = default
+      @description = description
+    end
+  end
+  
+  class PostCommand
+    attr_accessor :attributes, :uri, :name
+    
+    def initialize( uri, name="Send" )
+      @uri = uri
+      @name = name
+      @attributes = []
+    end
+   
+    def to_html
+      html = "<form method='POST' action='"+@uri.to_s+"'>"
+      html << "<pre><p>"
+      html << "<table border=0>"
+      #html << "<tr><td colspan='3'><i><sup>Mandatory params are marked with *.</sup></i></td></tr>"
+      attributes.each do |a|
+        mandatory_string = a.is_mandatory ? "*" : ""
+        html << "<tr><td>"+a.name.to_s+":"+mandatory_string+"</td>"
+        html << "<td><input type='text' name='"+a.name.to_s+
+          "' size='50' value='"+a.default.to_s+"'/></td>"
+        html << "<td><i><sup>"+a.description.to_s+"</sup></i></td></tr>"
+      end
+      html << "<tr><td colspan='3'><input type='submit' value='"+@name.to_s+"' /></td></tr>"
+      html << "</table></p></pre></form>"
+      html
+    end
+  end
 end
 
-=begin
-get '/logout/?' do
+get '/sign_out/?' do
   response.set_cookie("subjectid",{:value=>nil})
   content_type "text/html"
-  content = "Sucessfully logged out from "+$url_provider.url_for("",:full)
+  content = "Sucessfully signed out from "+$url_provider.url_for("",:full)
   OpenTox.text_to_html(content)
 end
 
-get '/login/?' do
+get '/sign_in/?' do
   content_type "text/html"
-  OpenTox.login
+  OpenTox.sign_in
 end
 
-post '/login/?' do
+post '/sign_in/?' do
   subjectid = OpenTox::Authorization.authenticate(params[:user], params[:password])
   if (subjectid)
     response.set_cookie("subjectid",{:value=>subjectid})
     content_type "text/html"
-    content = "Sucessfully logged in as '"+params[:user]+"' to "+$url_provider.url_for("",:full)
+    content = "Sucessfully signed in as '"+params[:user]+"' to "+$url_provider.url_for("",:full)
     OpenTox.text_to_html(content,subjectid)    
   else
     content_type "text/html"
-    OpenTox.login("Login failed, please try again")
+    OpenTox.sign_in("Login failed, please try again")
   end
 end
-=end
 

data/lib/validation.rb

@@ -36,6 +36,30 @@ module OpenTox
       Validation.new(uri)
     end
     
+    # creates a training test validation, waits until it finishes, may take some time
+    # @param [Hash] params (required:algorithm_uri,training_dataset_uri,prediction_feature,test_dataset_uri,optional:algorithm_params)
+    # @param [String,optional] subjectid
+    # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
+    # @return [OpenTox::Validation]
+    def self.create_training_test_validation( params, subjectid=nil, waiting_task=nil )
+      params[:subjectid] = subjectid if subjectid
+      uri = OpenTox::RestClientWrapper.post( File.join(CONFIG[:services]["opentox-validation"],"training_test_validation"),
+        params,{:content_type => "text/uri-list"},waiting_task )
+      Validation.new(uri)
+    end
+    
+    # creates a bootstrapping validation, waits until it finishes, may take some time
+    # @param [Hash] params (required:algorithm_uri,dataset_uri,prediction_feature, optional:algorithm_params,random_seed(1))
+    # @param [String,optional] subjectid
+    # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
+    # @return [OpenTox::Validation]
+    def self.create_bootstrapping_validation( params, subjectid=nil, waiting_task=nil )
+      params[:subjectid] = subjectid if subjectid
+      uri = OpenTox::RestClientWrapper.post( File.join(CONFIG[:services]["opentox-validation"],"bootstrapping"),
+        params,{:content_type => "text/uri-list"},waiting_task )
+      Validation.new(uri)
+    end
+    
     # looks for report for this validation, creates a report if no report is found
     # @param [String,optional] subjectid
     # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
@@ -61,34 +85,27 @@ module OpenTox
       @metadata = YAML.load(OpenTox::RestClientWrapper.get(uri,{:subjectid => subjectid, :accept => "application/x-yaml"}))
     end
     
-    # PENDING: creates summary as used for ToxCreate
-    def summary
-      if @metadata[OT.classificationStatistics]
-        res = {
-          :nr_predictions => @metadata[OT.numInstances] - @metadata[OT.numUnpredicted],
-          :correct_predictions => @metadata[OT.classificationStatistics][OT.percentCorrect],
-          :weighted_area_under_roc => @metadata[OT.classificationStatistics][OT.weightedAreaUnderRoc],
-        }
-        @metadata[OT.classificationStatistics][OT.classValueStatistics].each do |s|
-          if s[OT.classValue].to_s=="true"
-            res[:true_positives] = s[OT.numTruePositives]
-            res[:false_positives] = s[OT.numFalsePositives]
-            res[:true_negatives] = s[OT.numTrueNegatives]
-            res[:false_negatives] = s[OT.numFalseNegatives]
-            res[:sensitivity] = s[OT.truePositiveRate]
-            res[:specificity] = s[OT.trueNegativeRate]
-            break
+    # returns confusion matrix as array, predicted values are in rows
+    # example:
+    # [[nil,"active","moderate","inactive"],["active",1,3,99],["moderate",4,2,8],["inactive",3,8,6]]
+    # -> 99 inactive compounds have been predicted as active 
+    def confusion_matrix
+      raise "no classification statistics, probably a regression valdiation" unless @metadata[OT.classificationStatistics]
+      matrix =  @metadata[OT.classificationStatistics][OT.confusionMatrix][OT.confusionMatrixCell]
+      values = matrix.collect{|cell| cell[OT.confusionMatrixPredicted]}.uniq
+      table = [[nil]+values]
+      values.each do |c|
+        table << [c]
+        values.each do |r|
+          matrix.each do |cell|
+            if cell[OT.confusionMatrixPredicted]==c and cell[OT.confusionMatrixActual]==r
+              table[-1] << cell[OT.confusionMatrixValue].to_f
+              break
+            end
           end
         end
-        res
-      elsif @metadata[OT.regressionStatistics]
-        {
-          :nr_predictions => @metadata[OT.numInstances] - @metadata[OT.numUnpredicted],
-          :r_square => @metadata[OT.regressionStatistics][OT.rSquare],
-          :root_mean_squared_error => @metadata[OT.regressionStatistics][OT.rootMeanSquaredError],
-          :mean_absolute_error => @metadata[OT.regressionStatistics][OT.meanAbsoluteError],
-        }
       end
+      table
     end
   end
   
@@ -147,9 +164,9 @@ module OpenTox
       @metadata = YAML.load(OpenTox::RestClientWrapper.get(uri,{:subjectid => subjectid, :accept => "application/x-yaml"}))
     end
     
-    # PENDING: creates summary as used for ToxCreate
-    def summary( subjectid=nil )
-      Validation.from_cv_statistics( @uri, subjectid ).summary
+    # returns a Validation object containing the statistics of the crossavlidation
+    def statistics( subjectid=nil )
+      Validation.from_cv_statistics( @uri, subjectid )
     end
   end
   
@@ -198,7 +215,6 @@ module OpenTox
     # @param [String,optional] subjectid
     # @return [OpenTox::CrossvalidationReport]
     def self.find( uri, subjectid=nil )
-      # PENDING load report data?
       OpenTox::RestClientWrapper.get(uri,{:subjectid => subjectid})
       rep = CrossvalidationReport.new(uri)
       rep.load_metadata( subjectid )
@@ -227,6 +243,54 @@ module OpenTox
     end
   end
   
+  
+  class AlgorithmComparisonReport
+    include OpenTox
+    
+    # finds AlgorithmComparisonReport via uri, raises error if not found
+    # @param [String] uri
+    # @param [String,optional] subjectid
+    # @return [OpenTox::CrossvalidationReport]
+    def self.find( uri, subjectid=nil )
+      OpenTox::RestClientWrapper.get(uri,{:subjectid => subjectid})
+      rep = AlgorithmComparisonReport.new(uri)
+      rep.load_metadata( subjectid )
+      rep
+    end
+    
+    # finds AlgorithmComparisonReport for a particular crossvalidation
+    # @param [String] crossvalidation uri 
+    # @param [String,optional] subjectid
+    # @return [OpenTox::AlgorithmComparisonReport] nil if no report found
+    def self.find_for_crossvalidation( crossvalidation_uri, subjectid=nil )
+      uris = RestClientWrapper.get(File.join(CONFIG[:services]["opentox-validation"],
+        "/report/algorithm_comparison?crossvalidation="+crossvalidation_uri), {:subjectid => subjectid}).chomp.split("\n")
+      uris.size==0 ? nil : AlgorithmComparisonReport.new(uris[-1])
+    end
+    
+    # creates a crossvalidation report via crossvalidation
+    # @param [Hash] crossvalidation uri_hash, see example 
+    # @param [String,optional] subjectid
+    # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
+    # @return [OpenTox::AlgorithmComparisonReport]
+    # example for hash:
+    # { :lazar-bbrc => [ http://host/validation/crossvalidation/x1, http://host/validation/crossvalidation/x2 ],
+    #   :lazar-last => [ http://host/validation/crossvalidation/xy, http://host/validation/crossvalidation/xy ] }
+    def self.create( crossvalidation_uri_hash, subjectid=nil, waiting_task=nil )
+      identifier = []
+      validation_uris = []
+      crossvalidation_uri_hash.each do |id, uris|
+        uris.each do |uri|
+          identifier << id
+          validation_uris << uri
+        end
+      end
+      uri = RestClientWrapper.post(File.join(CONFIG[:services]["opentox-validation"],"/report/algorithm_comparison"),
+        { :validation_uris => validation_uris.join(","), :identifier => identifier.join(","), :subjectid => subjectid }, {}, waiting_task )
+      AlgorithmComparisonReport.new(uri)
+    end
+  end  
+  
   class QMRFReport
     include OpenTox