new feature: algorithm comparison report

10 files changed, 186 insertions, 178 deletions

diff --git a/report/plot_factory.rb b/report/plot_factory.rb
index b7c920a..74c89f5 100644
--- a/report/plot_factory.rb
+++ b/report/plot_factory.rb
@@ -167,25 +167,35 @@ module Reports
       validation_set.validations.each do |v|
         values = []
         value_attributes.each do |a|
-          validation_set.get_accept_values_for_attr(a).each do |class_value|
-            value = v.send(a)
-            if value.is_a?(Hash)
-              if class_value==nil
-                avg_value = 0
-                value.values.each{ |val| avg_value+=val }
-                value = avg_value/value.values.size.to_f
-              else
-                raise "bar plot value is hash, but no entry for class-value ("+class_value.to_s+"); value for "+a.to_s+" -> "+value.inspect unless value.key?(class_value)
-                value = value[class_value]
+          
+          accept = validation_set.get_accept_values_for_attr(a)
+          if accept and accept.size>0
+            accept.each do |class_value|
+              value = v.send(a)
+              if value.is_a?(Hash)
+                if class_value==nil
+                  avg_value = 0
+                  value.values.each{ |val| avg_value+=val }
+                  value = avg_value/value.values.size.to_f
+                else
+                  raise "bar plot value is hash, but no entry for class-value ("+class_value.to_s+"); value for "+a.to_s+" -> "+value.inspect unless value.key?(class_value)
+                  value = value[class_value]
+                end
               end
+              raise "value is nil\nattribute: "+a.to_s+"\nvalidation: "+v.inspect if value==nil
+              values.push(value)
+              labels.push(a.to_s.gsub("_","-") + ( class_value==nil ? "" : "("+class_value.to_s+")" ))
             end
-            raise "value is nil\nattribute: "+a.to_s+"\nvalidation: "+v.inspect if value==nil
+          else
+            value = v.send(a)
             values.push(value)
-            labels.push(a.to_s.gsub("_","-") + ( class_value==nil ? "" : "("+class_value.to_s+")" ))
+            labels.push(a.to_s.gsub("_","-"))
           end
+          
         end
         
         titles << v.send(title_attribute).to_s
+        raise "no title for '"+title_attribute.to_s+"' in validation: "+v.to_yaml if titles[-1].to_s.size==0
         data << values
       end
       
diff --git a/report/report_application.rb b/report/report_application.rb
index 258daa7..1637ead 100755
--- a/report/report_application.rb
+++ b/report/report_application.rb
@@ -114,7 +114,8 @@ end
 post '/report/:type' do
   task = OpenTox::Task.create("Create report",url_for("/report/"+params[:type], :full)) do |task| #,params
     perform do |rs|
-      rs.create_report(params[:type],params[:validation_uris]?params[:validation_uris].split(/\n|,/):nil,@subjectid,task)
+      rs.create_report(params[:type],params[:validation_uris]?params[:validation_uris].split(/\n|,/):nil,
+        params[:identifier]?params[:identifier].split(/\n|,/):nil,@subjectid,task)
     end
   end
   return_task(task)
diff --git a/report/report_content.rb b/report/report_content.rb
index cc4c13c..ac64bab 100755
--- a/report/report_content.rb
+++ b/report/report_content.rb
@@ -22,28 +22,32 @@ class Reports::ReportContent
     @current_section = @xml_report.get_root_element
   end
   
-  def add_paired_ttest_table( validation_set,
+  def add_paired_ttest_tables( validation_set,
                        group_attribute, 
-                       test_attribute,
+                       test_attributes,
                        section_title = "Paired t-test",
                        section_text = nil)
-                       
-    level = 0.90                       
-    test_matrix = Reports::ReportStatisticalTest.test_matrix( validation_set.validations, 
-      group_attribute, test_attribute, "paired_ttest", level )
-    #puts test_matrix.inspect
-    titles = test_matrix[:titles]
-    matrix = test_matrix[:matrix]
-    table = []
-    #puts titles.inspect
-    table << [""] + titles
-    titles.size.times do |i|
-      table << [titles[i]] + matrix[i].collect{|v| (v==nil || v==0) ? "" : (v<0 ? "-" : "+") }
-    end
-    
+
     section_test = @xml_report.add_section(@current_section, section_title)
     @xml_report.add_paragraph(section_test, section_text) if section_text
-    @xml_report.add_table(section_test, test_attribute.to_s+", significance-level: "+level.to_s, table, true, true)  
+      
+    test_attributes.each do |test_attribute|                    
+      level = 0.90                       
+      test_matrix = Reports::ReportStatisticalTest.test_matrix( validation_set.validations, 
+        group_attribute, test_attribute, "paired_ttest", level )
+      #puts test_matrix.inspect
+      titles = test_matrix[:titles]
+      matrix = test_matrix[:matrix]
+      table = []
+      #puts titles.inspect
+      table << [""] + titles
+      titles.size.times do |i|
+        table << [titles[i]] + matrix[i].collect{|v| (v==nil || v==0) ? "" : (v<0 ? "-" : "+") }
+      end
+      
+      @xml_report.add_table(section_test, test_attribute.to_s+", significance-level: "+level.to_s+", num results: "+
+        test_matrix[:num_results].to_s, table, true, true)
+    end
   end
   
   def add_predictions( validation_set, 
@@ -98,32 +102,13 @@ class Reports::ReportContent
                         validation_attributes,
                         table_title,
                         section_title="Results",
-                        section_text=nil,
-                        #rem_equal_vals_attr=[],
-                        search_for_existing_report_type=nil)
+                        section_text=nil)
+                        #rem_equal_vals_attr=[])
 
     section_table = @xml_report.add_section(@current_section, section_title)
     @xml_report.add_paragraph(section_table, section_text) if section_text
     vals = validation_set.to_array(validation_attributes, true)
     vals = vals.collect{|a| a.collect{|v| v.to_s }}
-    
-    if (search_for_existing_report_type)
-      vals.size.times do |i|
-        #puts i
-        if (i==0)
-          vals[i] = [ "Reports" ] + vals[i]
-          puts vals[i].inspect
-        else
-          if search_for_existing_report_type=="validation"
-            vals[i] = [ validation_set.validations[i-1].validation_report_uri() ] + vals[i]
-          elsif search_for_existing_report_type=="crossvalidation"
-            vals[i] = [ validation_set.validations[i-1].cv_report_uri() ] + vals[i]
-          else
-            raise "illegal report type: "+search_for_existing_report_type.to_s
-          end
-        end
-      end
-    end
     #PENDING transpose values if there more than 4 columns, and there are more than columns than rows
     transpose = vals[0].size>4 && vals[0].size>vals.size
     @xml_report.add_table(section_table, table_title, vals, !transpose, transpose, transpose)
diff --git a/report/report_factory.rb b/report/report_factory.rb
index 08d9418..7e74cb4 100755
--- a/report/report_factory.rb
+++ b/report/report_factory.rb
@@ -100,33 +100,37 @@ module Reports::ReportFactory
     raise OpenTox::BadRequestError.new("validations must have unique feature type, i.e. must be either all regression, "+
       +"or all classification validations") unless validation_set.unique_feature_type  
     pre_load_predictions( validation_set, OpenTox::SubTask.create(task,0,80) )
+    validation_set.validations.sort! do |x,y|
+      x.crossvalidation_fold.to_f <=> y.crossvalidation_fold.to_f
+    end
+    cv_set = validation_set.replace_with_cv_stats
+    raise unless cv_set.size==1
     
-    merged = validation_set.merge([:crossvalidation_id])
-    raise unless merged.size==1
-    
-    #puts merged.get_values(:percent_correct_variance, false).inspect
+    #puts cv_set.get_values(:percent_correct_variance, false).inspect
     report = Reports::ReportContent.new("Crossvalidation report")
+    res_titel = "Crossvalidation Results"
+    res_text = "These performance statistics have been derieved by accumulating all predictions on the various fold (i.e. these numbers are NOT averaged results over all crossvalidation folds)."
     
     case validation_set.unique_feature_type
     when "classification"
-      report.add_result(merged, [:crossvalidation_uri]+VAL_ATTR_CV+VAL_ATTR_CLASS-[:crossvalidation_fold],"Mean Results","Mean Results")
-      report.add_confusion_matrix(merged.validations[0])
+      report.add_result(cv_set, [:crossvalidation_uri]+VAL_ATTR_CV+VAL_ATTR_CLASS-[:crossvalidation_fold], res_titel, res_titel, res_text)
+      report.add_confusion_matrix(cv_set.validations[0])
       report.add_section("Plots")
       report.add_roc_plot(validation_set)
       report.add_roc_plot(validation_set, :crossvalidation_fold)
       report.add_confidence_plot(validation_set)
       report.add_confidence_plot(validation_set, :crossvalidation_fold)
       report.end_section
-      report.add_result(validation_set, VAL_ATTR_CV+VAL_ATTR_CLASS-[:num_folds],
-        "Results","Results",nil,"validation")
+      report.add_result(validation_set, [:validation_uri, :validation_report_uri]+VAL_ATTR_CV+VAL_ATTR_CLASS-[:num_folds, :dataset_uri, :algorithm_uri],
+        "Results","Results")
     when "regression"
-      report.add_result(merged, [:crossvalidation_uri]+VAL_ATTR_CV+VAL_ATTR_REGR-[:crossvalidation_fold],"Mean Results","Mean Results")
+      report.add_result(cv_set, [:crossvalidation_uri]+VAL_ATTR_CV+VAL_ATTR_REGR-[:crossvalidation_fold],res_titel, res_titel, res_text)
       report.add_section("Plots")
       report.add_regression_plot(validation_set, :crossvalidation_fold)
       report.add_confidence_plot(validation_set)
       report.add_confidence_plot(validation_set, :crossvalidation_fold)
       report.end_section
-      report.add_result(validation_set, VAL_ATTR_CV+VAL_ATTR_REGR-[:num_folds], "Results","Results")
+      report.add_result(validation_set, [:validation_uri, :validation_report_uri]+VAL_ATTR_CV+VAL_ATTR_REGR-[:num_folds, :dataset_uri, :algorithm_uri], "Results","Results")
     end
     task.progress(90) if task
       
@@ -142,8 +146,8 @@ module Reports::ReportFactory
     raise OpenTox::BadRequestError.new("num validations is not >1") unless validation_set.size>1
     raise OpenTox::BadRequestError.new("validations must have unique feature type, i.e. must be either all regression, "+
       +"or all classification validations") unless validation_set.unique_feature_type
-    raise OpenTox::BadRequestError.new("number of different algorithms <2: "+
-      validation_set.get_values(:algorithm_uri).inspect) if validation_set.num_different_values(:algorithm_uri)<2
+    raise OpenTox::BadRequestError.new("number of different identifiers <2: "+
+      validation_set.get_values(:identifier).inspect) if validation_set.num_different_values(:identifier)<2
       
     if validation_set.has_nil_values?(:crossvalidation_id)
       raise OpenTox::BadRequestError.new("algorithm comparison for non crossvalidation not yet implemented")
@@ -160,73 +164,63 @@ module Reports::ReportFactory
     
     # groups results into sets with equal dataset 
     if (validation_set.num_different_values(:dataset_uri)>1)
+      LOGGER.debug "compare report -- num different datasets: "+validation_set.num_different_values(:dataset_uri).to_s
       dataset_grouping = Reports::Util.group(validation_set.validations, [:dataset_uri])
       # check if equal values in each group exist
-      Reports::Util.check_group_matching(dataset_grouping, [:algorithm_uri, :crossvalidation_fold, :num_folds, :stratified, :random_seed])
+      Reports::Util.check_group_matching(dataset_grouping, [:crossvalidation_fold, :num_folds, :stratified, :random_seed])
     else
       dataset_grouping = [ validation_set.validations ]
     end
     
-    # we only checked that equal validations exist in each dataset group, now check for each algorithm
+    # we only checked that equal validations exist in each dataset group, now check for each identifier
     dataset_grouping.each do |validations|
-      algorithm_grouping = Reports::Util.group(validations, [:algorithm_uri])
+      algorithm_grouping = Reports::Util.group(validations, [:identifier])
       Reports::Util.check_group_matching(algorithm_grouping, [:crossvalidation_fold, :num_folds, :stratified, :random_seed])
     end
     
     pre_load_predictions( validation_set, OpenTox::SubTask.create(task,0,80) )
-    report = Reports::ReportContent.new("Algorithm comparison report - Many datasets")
+    report = Reports::ReportContent.new("Algorithm comparison report")
     
     if (validation_set.num_different_values(:dataset_uri)>1)
       all_merged = validation_set.merge([:algorithm_uri, :dataset_uri, :crossvalidation_id, :crossvalidation_uri])
       report.add_ranking_plots(all_merged, :algorithm_uri, :dataset_uri,
         [:percent_correct, :weighted_area_under_roc, :true_positive_rate, :true_negative_rate] )
       report.add_result_overview(all_merged, :algorithm_uri, :dataset_uri, [:percent_correct, :weighted_area_under_roc, :true_positive_rate, :true_negative_rate])
-      
     end
-
+      
+    result_attributes = [:identifier,:crossvalidation_uri,:crossvalidation_report_uri]+VAL_ATTR_CV-[:crossvalidation_fold,:num_folds,:dataset_uri]
     case validation_set.unique_feature_type
     when "classification"
-      attributes = VAL_ATTR_CV+VAL_ATTR_CLASS-[:crossvalidation_fold]
-      attributes = ([ :dataset_uri ] + attributes).uniq
-      
-      dataset_grouping.each do |validations|
-      
-        set = Reports::ValidationSet.create(validations)
-        
-        dataset = validations[0].dataset_uri
-        merged = set.merge([:algorithm_uri, :dataset_uri, :crossvalidation_id, :crossvalidation_uri])
-        merged.sort(:dataset_uri)
-        
-        report.add_section("Dataset: "+dataset)
-        report.add_result(merged,attributes,
-          "Mean Results","Mean Results",nil,"crossvalidation")
-        report.add_paired_ttest_table(set, :algorithm_uri, :percent_correct)
-        
-        report.add_bar_plot(merged, :algorithm_uri, VAL_ATTR_BAR_PLOT_CLASS)
-        report.add_roc_plot(set, :algorithm_uri)
-        report.end_section
-      end
-      
-    when "regression"
+      result_attributes += VAL_ATTR_CLASS
+      ttest_attributes = [:percent_correct, :weighted_area_under_roc]
+      bar_plot_attributes = VAL_ATTR_BAR_PLOT_CLASS
+    else 
+      result_attributes += VAL_ATTR_REGR
+      ttest_attributes = [:r_square, :root_mean_squared_error]
+      bar_plot_attributes = VAL_ATTR_BAR_PLOT_REGR
+    end
       
-      attributes = VAL_ATTR_CV+VAL_ATTR_REGR-[:crossvalidation_fold]
-      attributes = ([ :dataset_uri ] + attributes).uniq
+    dataset_grouping.each do |validations|
+    
+      set = Reports::ValidationSet.create(validations)
       
-      dataset_grouping.each do |validations|
+      dataset = validations[0].dataset_uri
+      merged = set.merge([:identifier, :dataset_uri]) #, :crossvalidation_id, :crossvalidation_uri])
+      merged.sort(:identifier)
       
-        set = Reports::ValidationSet.create(validations)
-        
-        dataset = validations[0].dataset_uri
-        merged = set.merge([:algorithm_uri, :dataset_uri, :crossvalidation_id, :crossvalidation_uri])
-        merged.sort(:dataset_uri)
-        
-        report.add_section("Dataset: "+dataset)
-        report.add_result(merged,attributes,
-          "Mean Results","Mean Results",nil,"crossvalidation")
-        report.add_paired_ttest_table(set, :algorithm_uri, :r_square)
-        report.end_section
+      merged.validations.each do |v|
+        v.crossvalidation_uri = v.crossvalidation_uri.split(";").uniq.join(" ")
+        v.crossvalidation_report_uri = v.crossvalidation_report_uri.split(";").uniq.join(" ") if  v.crossvalidation_report_uri
       end
       
+      report.add_section("Dataset: "+dataset)
+      res_titel = "Average Results on Folds"
+      res_text = "These performance statistics have been derieved by computing the mean of the statistics on each crossvalidation fold."
+      report.add_result(merged,result_attributes,res_titel,res_titel,res_text)
+      # pending: regression stats have different scales!!!
+      report.add_bar_plot(merged, :identifier, bar_plot_attributes) if validation_set.unique_feature_type=="classification"
+      report.add_paired_ttest_tables(set, :identifier, ttest_attributes)
+      report.end_section
     end
     task.progress(100) if task
     report
diff --git a/report/report_persistance.rb b/report/report_persistance.rb
index c85ad68..78ae47b 100755
--- a/report/report_persistance.rb
+++ b/report/report_persistance.rb
@@ -250,6 +250,7 @@ module Reports
     end
     
     def list_reports(type, filter_params={})
+      filter_params[:report_type] = type
       LOGGER.debug "find reports for params: "+filter_params.inspect
       reports = Lib::OhmUtil.find( ReportData, filter_params )
       reports.collect{ |r| r.id }
diff --git a/report/report_service.rb b/report/report_service.rb
index 722c3d6..3e23889 100644
--- a/report/report_service.rb
+++ b/report/report_service.rb
@@ -60,7 +60,7 @@ module Reports
     # call-seq:
     #   create_report(type, validation_uris) => string
     # 
-    def create_report(type, validation_uris, subjectid=nil, task=nil)
+    def create_report(type, validation_uris, identifier=nil, subjectid=nil, task=nil)
       
       LOGGER.info "create report of type '"+type.to_s+"'"
       check_report_type(type)
@@ -68,7 +68,10 @@ module Reports
       # step1: load validations
       raise OpenTox::BadRequestError.new("validation_uris missing") unless validation_uris
       LOGGER.debug "validation_uri(s): '"+validation_uris.inspect+"'"
-      validation_set = Reports::ValidationSet.new(validation_uris, subjectid)
+      LOGGER.debug "identifier: '"+identifier.inspect+"'"
+      raise "illegal num identifiers: "+identifier.size.to_s+" should be equal to num validation-uris ("+validation_uris.size.to_s+")" if
+        identifier and identifier.size!=validation_uris.size
+      validation_set = Reports::ValidationSet.new(validation_uris, identifier, subjectid)
       raise OpenTox::BadRequestError.new("cannot get validations from validation_uris '"+validation_uris.inspect+"'") unless validation_set and validation_set.size > 0
       LOGGER.debug "loaded "+validation_set.size.to_s+" validation/s"
       task.progress(10) if task
diff --git a/report/statistical_test.rb b/report/statistical_test.rb
index c37827e..1e586e2 100644
--- a/report/statistical_test.rb
+++ b/report/statistical_test.rb
@@ -58,7 +58,7 @@ module Reports
           end
         end
       end
-      {:titles => titles, :matrix => matrix}
+      {:titles => titles, :matrix => matrix, :num_results => grouped_validations[0].size}
     end
     
     def self.paired_ttest( validations1, validations2, attribute, significance_level=0.95 )
diff --git a/report/validation_access.rb b/report/validation_access.rb
index d0c3a1d..ffb7461 100755
--- a/report/validation_access.rb
+++ b/report/validation_access.rb
@@ -7,8 +7,9 @@ require "lib/validation_db.rb"
 #  
 class Reports::ValidationDB
   
-  def resolve_cv_uris(validation_uris, subjectid=nil)
-    res = []
+  def resolve_cv_uris(validation_uris, identifier=nil, subjectid=nil)
+    res = {}
+    count = 0
     validation_uris.each do |u|
       if u.to_s =~ /.*\/crossvalidation\/[0-9]+/
         cv_id = u.split("/")[-1].to_i
@@ -25,10 +26,13 @@ class Reports::ValidationDB
         raise OpenTox::NotFoundError.new "crossvalidation with id "+cv_id.to_s+" not found" unless cv
         raise OpenTox::BadRequestError.new("crossvalidation with id '"+cv_id.to_s+"' not finished") unless cv.finished
         #res += Validation::Validation.find( :all, :conditions => { :crossvalidation_id => cv_id } ).collect{|v| v.validation_uri.to_s}
-        res += Validation::Validation.find( :crossvalidation_id => cv_id, :validation_type => "crossvalidation" ).collect{|v| v.validation_uri.to_s }
+        Validation::Validation.find( :crossvalidation_id => cv_id, :validation_type => "crossvalidation" ).each do |v|
+          res[v.validation_uri.to_s] = identifier ? identifier[count] : nil
+        end
       else
-        res += [u.to_s]
+        res[u.to_s] = identifier ? identifier[count] : nil
       end
+      count += 1
     end
     res
   end
diff --git a/report/validation_data.rb b/report/validation_data.rb
index 11fa737..0c15dd2 100755
--- a/report/validation_data.rb
+++ b/report/validation_data.rb
@@ -1,6 +1,7 @@
 
 # the variance is computed when merging results for these attributes 
-VAL_ATTR_VARIANCE = [ :area_under_roc, :percent_correct, :root_mean_squared_error, :mean_absolute_error, :r_square, :accuracy  ]
+VAL_ATTR_VARIANCE = [ :area_under_roc, :percent_correct, :root_mean_squared_error, :mean_absolute_error, 
+  :r_square, :accuracy, :weighted_area_under_roc, :weighted_accuracy  ]
 VAL_ATTR_RANKING = [ :area_under_roc, :percent_correct, :true_positive_rate, :true_negative_rate, :weighted_area_under_roc ] #:accuracy ]
 
 ATTR_NICE_NAME = {}
@@ -51,21 +52,31 @@ end
 
 module Reports
   
+  @@validation_access = ValidationDB.new
+  @@persistance = ReportService.persistance
+  
+  def self.persistance
+    @@persistance
+  end
+  
+  def self.validation_access
+    @@validation_access
+  end
+  
+  # for overwriting validation source (other than using webservices)
+  def self.reset_validation_access(validation_access)
+    @@validation_access = validation_access
+  end
+  
+  
   # = ReportValidation
   #
   # contains all values of a validation object
   #
   class ReportValidation
     
-    @@validation_access = ValidationDB.new
-    
-    # for overwriting validation source (other than using webservices)
-    def self.reset_validation_access(validation_access)
-      @@validation_access = validation_access
-    end
-    
-    def self.resolve_cv_uris(validation_uris, subjectid)
-      @@validation_access.resolve_cv_uris(validation_uris, subjectid)
+    def self.resolve_cv_uris(validation_uris, identifier, subjectid)
+      Reports.validation_access.resolve_cv_uris(validation_uris, identifier, subjectid)
     end
     
     # create member variables for all validation properties
@@ -75,16 +86,17 @@ module Reports
     @@validation_attributes.each{ |a| attr_accessor a } 
   
     attr_reader :predictions
+    attr_accessor :identifier, :validation_report_uri, :crossvalidation_report_uri
     
     def initialize(uri = nil, subjectid = nil)
-      @@validation_access.init_validation(self, uri, subjectid) if uri
+      Reports.validation_access.init_validation(self, uri, subjectid) if uri
       @subjectid = subjectid
       #raise "subjectid is nil" unless subjectid
     end
     
     def self.from_cv_statistics( cv_uri, subjectid = nil )
       v = ReportValidation.new(nil, subjectid)
-      @@validation_access.init_validation_from_cv_statistics(v, cv_uri, subjectid)
+      Reports.validation_access.init_validation_from_cv_statistics(v, cv_uri, subjectid)
       v
     end
   
@@ -103,7 +115,7 @@ module Reports
           task.progress(100) if task
           nil
         else
-          @predictions = @@validation_access.get_predictions( self, @subjectid, task )
+          @predictions = Reports.validation_access.get_predictions( self, @subjectid, task )
         end
       end
     end
@@ -111,7 +123,7 @@ module Reports
     # returns the predictions feature values (i.e. the domain of the class attribute)
     #
     def get_accept_values()
-      @accept_values = @@validation_access.get_accept_values(self, @subjectid) unless @accept_values
+      @accept_values = Reports.validation_access.get_accept_values(self, @subjectid) unless @accept_values
       @accept_values
     end
     
@@ -119,36 +131,21 @@ module Reports
     #
     def feature_type
       return @feature_type if @feature_type!=nil
-      @feature_type = @@validation_access.feature_type(self, @subjectid) 
+      @feature_type = Reports.validation_access.feature_type(self, @subjectid) 
     end
     
     def predicted_variable
       return @predicted_variable if @predicted_variable!=nil
-      @predicted_variable = @@validation_access.predicted_variable(self, @subjectid) 
+      @predicted_variable = Reports.validation_access.predicted_variable(self, @subjectid) 
     end
     
     # loads all crossvalidation attributes, of the corresponding cv into this object 
     def load_cv_attributes
       raise "crossvalidation-id not set" unless @crossvalidation_id
-      @@validation_access.init_cv(self)
-    end
-    
-    @@persistance = ReportService.persistance
-    
-    def validation_report_uri
-      #puts "searching for validation report: "+self.validation_uri.to_s
-      return @validation_report_uri if @validation_report_uri!=nil
-      ids = @@persistance.list_reports("validation",{:validation_uris=>validation_uri })
-      @validation_report_uri = ReportService.instance.get_uri("validation",ids[-1]) if ids and ids.size>0
-    end
-    
-    def cv_report_uri
-      #puts "searching for cv report: "+self.crossvalidation_uri.to_s
-      return @cv_report_uri if @cv_report_uri!=nil
-      raise "no cv uri "+to_yaml unless self.crossvalidation_uri
-      ids = @@persistance.list_reports("crossvalidation",{:crossvalidation=>self.crossvalidation_uri.to_s })
-      #puts "-> "+ids.inspect
-      @cv_report_uri = ReportService.instance.get_uri("crossvalidation",ids[-1]) if ids and ids.size>0
+      Reports.validation_access.init_cv(self)
+      # load cv report
+      ids = Reports.persistance.list_reports("crossvalidation",{:crossvalidation=>self.crossvalidation_uri.to_s })
+      @crossvalidation_report_uri = ReportService.instance.get_uri("crossvalidation",ids[-1]) if ids and ids.size>0
     end
     
     def clone_validation
@@ -164,13 +161,20 @@ module Reports
   #
   class ValidationSet
     
-    def initialize(validation_uris=nil, subjectid=nil)
+    def initialize(validation_uris=nil, identifier=nil, subjectid=nil)
       @unique_values = {}
-      validation_uris = ReportValidation.resolve_cv_uris(validation_uris, subjectid) if validation_uris
-      @validations = Array.new
-      validation_uris.each{|u| @validations.push(ReportValidation.new(u, subjectid))} if validation_uris
+      @validations = []
+      if validation_uris    
+        validation_uri_and_ids = ReportValidation.resolve_cv_uris(validation_uris, identifier, subjectid)
+        validation_uri_and_ids.each do |u,id|
+          v = ReportValidation.new(u, subjectid)
+          v.identifier = id if id
+          ids = Reports.persistance.list_reports("validation",{:validation_uris=>v.validation_uri })
+          v.validation_report_uri = ReportService.instance.get_uri("validation",ids[-1]) if ids and ids.size>0
+          @validations << v
+        end
+      end
     end
-
   
     def self.create(validations)
       set = ValidationSet.new
@@ -399,6 +403,17 @@ module Reports
       return array
     end
     
+    def replace_with_cv_stats
+      new_set = ValidationSet.new
+      grouping = Util.group(@validations, [:crossvalidation_id])
+      grouping.each do |g|
+        v = ReportValidation.from_cv_statistics(g[0].crossvalidation_uri)
+        v.identifier = g.collect{|vv| vv.identifier}.uniq.join(";")
+        new_set.validations << v 
+      end
+      return new_set
+    end
+    
     # creates a new validaiton set, that contains merged validations
     # all validation with equal values for __equal_attributes__ are summed up in one validation, i.e. merged 
     #
@@ -416,31 +431,16 @@ module Reports
       grouping = Util.group(@validations, equal_attributes)
       #puts "groups "+grouping.size.to_s
 
-      if ( equal_attributes.include?(:crossvalidation_id) )
-        # do not merge, use crossvalidation statistics
-        raise "statistics vs merging problem" if equal_attributes.size!=1
-        grouping.each do |g|
-          new_set.validations << ReportValidation.from_cv_statistics(g[0].crossvalidation_uri)
-        end
-      else
-        #merge
-        Lib::MergeObjects.register_merge_attributes( ReportValidation,
-          Validation::VAL_MERGE_AVG,Validation::VAL_MERGE_SUM,Validation::VAL_MERGE_GENERAL) unless 
-            Lib::MergeObjects.merge_attributes_registered?(ReportValidation)
-        grouping.each do |g|
-          new_set.validations << g[0].clone_validation
-          w = 1
-          g[1..-1].each do |v|
-            new_set.validations[-1] = Lib::MergeObjects.merge_objects(new_set.validations[-1],v,w,1)
-            w+=1
-          end
+      #merge
+      Lib::MergeObjects.register_merge_attributes( ReportValidation,
+        Validation::VAL_MERGE_AVG+Validation::VAL_MERGE_SUM,[],Validation::VAL_MERGE_GENERAL+[:identifier, :validation_report_uri, :crossvalidation_report_uri]) unless 
+          Lib::MergeObjects.merge_attributes_registered?(ReportValidation)
+      grouping.each do |g|
+        new_set.validations << g[0].clone_validation
+        g[1..-1].each do |v|
+          new_set.validations[-1] = Lib::MergeObjects.merge_objects(new_set.validations[-1],v)
         end
       end
-      
-      new_set.validations.each do |v|
-        raise "not a validation "+v.class.to_s+" "+v.to_s unless v.is_a?(Reports::ReportValidation)
-      end
-      
       return new_set
     end
     
diff --git a/report/xml_report.rb b/report/xml_report.rb
index 4fbfae3..7467c47 100755
--- a/report/xml_report.rb
+++ b/report/xml_report.rb
@@ -187,7 +187,13 @@ module Reports
           if auto_link_urls && v.to_s =~ /depict/ || v.to_s =~ /image\/png$/ #PENDING 
             add_image(entry, v.to_s)
           elsif auto_link_urls && v.to_s =~ /^http(s?):\/\//
-           add_url(entry, v.to_s, v.to_s)
+           #add_url(entry, v.to_s, v.to_s)
+           v.to_s.split(" ").each do |vv|
+              add_url(entry, vv.to_s, vv.to_s)
+              space = Element.new("para")
+              space.text = " "
+              entry << space
+           end
           else
            entry.text = v.to_s
           end
@@ -221,11 +227,15 @@ module Reports
       return list
     end
     
-    def add_url (element, url, description=url )
-      
+    def url_element( url, description=url )
       ulink = Element.new("ulink")
       ulink.add_attributes({"url" => url})
       ulink.text = description
+      ulink
+    end
+    
+    def add_url (element, url, description=url )
+      ulink = url_element(url, description)
       element << ulink
       return ulink
     end