in progress...
[jalview.git] / forester / java / src / org / forester / surfacing / BasicDomainSimilarityCalculator.java
index c4c5ab7..8682fd1 100644 (file)
@@ -42,12 +42,25 @@ import org.forester.util.ForesterUtil;
 
 public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculator {
 
-    final PrintableDomainSimilarity.DomainSimilaritySortField _sort;
-    private final boolean                                     _calc_similarity_score;
-    private final boolean                                     _sort_by_species_count_first;
-    private final boolean                                     _treat_as_binary_comparison;
+    final DomainSimilarity.DomainSimilaritySortField _sort;
+    private final boolean                            _calc_similarity_score;
+    private final boolean                            _sort_by_species_count_first;
+    private final boolean                            _treat_as_binary_comparison;
+    private final boolean                            _verbose;
 
-    public BasicDomainSimilarityCalculator( final PrintableDomainSimilarity.DomainSimilaritySortField sort,
+    public BasicDomainSimilarityCalculator( final DomainSimilarity.DomainSimilaritySortField sort,
+                                            final boolean sort_by_species_count_first,
+                                            final boolean treat_as_binary_comparison,
+                                            final boolean calc_similarity_score,
+                                            final boolean verbose ) {
+        _sort = sort;
+        _sort_by_species_count_first = sort_by_species_count_first;
+        _treat_as_binary_comparison = treat_as_binary_comparison;
+        _calc_similarity_score = calc_similarity_score;
+        _verbose = verbose;
+    }
+
+    public BasicDomainSimilarityCalculator( final DomainSimilarity.DomainSimilaritySortField sort,
                                             final boolean sort_by_species_count_first,
                                             final boolean treat_as_binary_comparison,
                                             final boolean calc_similarity_score ) {
@@ -55,26 +68,31 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
         _sort_by_species_count_first = sort_by_species_count_first;
         _treat_as_binary_comparison = treat_as_binary_comparison;
         _calc_similarity_score = calc_similarity_score;
+        _verbose = false;
     }
 
     @Override
-    public SortedSet<PrintableDomainSimilarity> calculateSimilarities( final PairwiseDomainSimilarityCalculator pairwise_calculator,
-                                                                       final List<GenomeWideCombinableDomains> cdc_list,
-                                                                       final boolean ignore_domains_without_combinations_in_any_genome,
-                                                                       final boolean ignore_domains_specific_to_one_genome ) {
+    public SortedSet<DomainSimilarity> calculateSimilarities( final PairwiseDomainSimilarityCalculator pairwise_calculator,
+                                                              final List<GenomeWideCombinableDomains> cdc_list,
+                                                              final boolean ignore_domains_without_combinations_in_any_genome,
+                                                              final boolean ignore_domains_specific_to_one_genome ) {
         if ( cdc_list.size() < 2 ) {
             throw new IllegalArgumentException( "attempt to calculate multiple combinable domains similarity for less than two combinale domains collections" );
         }
-        final SortedSet<PrintableDomainSimilarity> similarities = new TreeSet<PrintableDomainSimilarity>();
+        final SortedSet<DomainSimilarity> similarities = new TreeSet<DomainSimilarity>();
         final SortedSet<String> keys = new TreeSet<String>();
         for( final GenomeWideCombinableDomains cdc : cdc_list ) {
             keys.addAll( ( cdc ).getAllCombinableDomainsIds().keySet() );
         }
         final DecimalFormat pf = new java.text.DecimalFormat( "000000" );
         int counter = 1;
-        System.out.println( keys.size() );
+        if ( _verbose ) {
+            System.out.println( keys.size() );
+        }
         for( final String key : keys ) {
-            ForesterUtil.updateProgress( counter, pf );
+            if ( _verbose ) {
+                ForesterUtil.updateProgress( counter, pf );
+            }
             counter++;
             final List<CombinableDomains> same_id_cd_list = new ArrayList<CombinableDomains>( cdc_list.size() );
             final List<Species> species_with_key_id_domain = new ArrayList<Species>();
@@ -98,7 +116,7 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
             }
             if ( same_id_cd_list.size() > 0 ) {
                 if ( !ignore_domains_specific_to_one_genome || ( same_id_cd_list.size() > 1 ) ) {
-                    final PrintableDomainSimilarity s = calculateSimilarity( pairwise_calculator, same_id_cd_list );
+                    final DomainSimilarity s = calculateSimilarity( pairwise_calculator, same_id_cd_list );
                     if ( s != null ) {
                         similarities.add( s );
                     }
@@ -111,7 +129,9 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
                 throw new RuntimeException( "this should not have happened" );
             }
         }
-        System.out.println();
+        if ( _verbose ) {
+            System.out.println();
+        }
         return similarities;
     }
 
@@ -119,33 +139,33 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
         return _calc_similarity_score;
     }
 
-    private PrintableDomainSimilarity calculateSimilarity( final PairwiseDomainSimilarityCalculator pairwise_calculator,
-                                                           final List<CombinableDomains> domains_list ) {
+    private DomainSimilarity calculateSimilarity( final PairwiseDomainSimilarityCalculator pairwise_calculator,
+                                                  final List<CombinableDomains> domains_list ) {
         if ( domains_list.size() == 1 ) {
             final SortedMap<Species, SpeciesSpecificDcData> species_data = new TreeMap<Species, SpeciesSpecificDcData>();
             species_data.put( domains_list.get( 0 ).getSpecies(),
                               createSpeciesSpecificDomainSimilariyData( domains_list.get( 0 ) ) );
             if ( !isCalcSimilarityScore() ) {
-                return new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                      0,
-                                                      0,
-                                                      species_data,
-                                                      isSortBySpeciesCountFirst(),
-                                                      isTreatAsBinaryComparison() );
+                return new DomainSimilarity( domains_list.get( 0 ),
+                                             0,
+                                             0,
+                                             species_data,
+                                             isSortBySpeciesCountFirst(),
+                                             isTreatAsBinaryComparison() );
             }
             else {
-                return new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                      1.0,
-                                                      1.0,
-                                                      1.0,
-                                                      1.0,
-                                                      0.0,
-                                                      0,
-                                                      0,
-                                                      0,
-                                                      species_data,
-                                                      isSortBySpeciesCountFirst(),
-                                                      isTreatAsBinaryComparison() );
+                return new DomainSimilarity( domains_list.get( 0 ),
+                                             1.0,
+                                             1.0,
+                                             1.0,
+                                             1.0,
+                                             0.0,
+                                             0,
+                                             0,
+                                             0,
+                                             species_data,
+                                             isSortBySpeciesCountFirst(),
+                                             isTreatAsBinaryComparison() );
             }
         }
         DescriptiveStatistics stat = null;
@@ -199,43 +219,43 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
                 max_difference = Math.abs( max_difference );
             }
         }
-        PrintableDomainSimilarity similarity = null;
+        DomainSimilarity similarity = null;
         if ( !isCalcSimilarityScore() ) {
-            similarity = new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                        max_difference_in_counts,
-                                                        max_difference,
-                                                        species_data,
-                                                        isSortBySpeciesCountFirst(),
-                                                        isTreatAsBinaryComparison() );
+            similarity = new DomainSimilarity( domains_list.get( 0 ),
+                                               max_difference_in_counts,
+                                               max_difference,
+                                               species_data,
+                                               isSortBySpeciesCountFirst(),
+                                               isTreatAsBinaryComparison() );
         }
         else {
             if ( stat.getN() == 1 ) {
-                similarity = new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                            stat.getMin(),
-                                                            stat.getMax(),
-                                                            stat.arithmeticMean(),
-                                                            stat.median(),
-                                                            0.0,
-                                                            stat.getN(),
-                                                            max_difference_in_counts,
-                                                            max_difference,
-                                                            species_data,
-                                                            isSortBySpeciesCountFirst(),
-                                                            isTreatAsBinaryComparison() );
+                similarity = new DomainSimilarity( domains_list.get( 0 ),
+                                                   stat.getMin(),
+                                                   stat.getMax(),
+                                                   stat.arithmeticMean(),
+                                                   stat.median(),
+                                                   0.0,
+                                                   stat.getN(),
+                                                   max_difference_in_counts,
+                                                   max_difference,
+                                                   species_data,
+                                                   isSortBySpeciesCountFirst(),
+                                                   isTreatAsBinaryComparison() );
             }
             else {
-                similarity = new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                            stat.getMin(),
-                                                            stat.getMax(),
-                                                            stat.arithmeticMean(),
-                                                            stat.median(),
-                                                            stat.sampleStandardDeviation(),
-                                                            stat.getN(),
-                                                            max_difference_in_counts,
-                                                            max_difference,
-                                                            species_data,
-                                                            isSortBySpeciesCountFirst(),
-                                                            isTreatAsBinaryComparison() );
+                similarity = new DomainSimilarity( domains_list.get( 0 ),
+                                                   stat.getMin(),
+                                                   stat.getMax(),
+                                                   stat.arithmeticMean(),
+                                                   stat.median(),
+                                                   stat.sampleStandardDeviation(),
+                                                   stat.getN(),
+                                                   max_difference_in_counts,
+                                                   max_difference,
+                                                   species_data,
+                                                   isSortBySpeciesCountFirst(),
+                                                   isTreatAsBinaryComparison() );
             }
         }
         return similarity;