forester/java/src/org/forester/surfacing/BasicGenomeWideCombinableDomains.java

   1
   2 package org.forester.surfacing;
   3
   4 import java.text.DecimalFormat;
   5 import java.text.NumberFormat;
   6 import java.util.ArrayList;
   7 import java.util.Collections;
   8 import java.util.Comparator;
   9 import java.util.HashMap;
  10 import java.util.HashSet;
  11 import java.util.List;
  12 import java.util.Map;
  13 import java.util.Set;
  14 import java.util.SortedMap;
  15 import java.util.SortedSet;
  16 import java.util.TreeMap;
  17 import java.util.TreeSet;
  18
  19 import org.forester.go.GoId;
  20 import org.forester.surfacing.BinaryDomainCombination.DomainCombinationType;
  21 import org.forester.util.BasicDescriptiveStatistics;
  22 import org.forester.util.DescriptiveStatistics;
  23 import org.forester.util.ForesterUtil;
  24
  25 public class BasicGenomeWideCombinableDomains implements GenomeWideCombinableDomains {
  26
  27     private final static NumberFormat                    FORMATTER                                  = new DecimalFormat( "0.0E0" );
  28     private static final Comparator<CombinableDomains>   DESCENDING_KEY_DOMAIN_COUNT_ORDER          = new Comparator<CombinableDomains>() {
  29
  30                                                                                                         public int compare( final CombinableDomains d1,
  31                                                                                                                             final CombinableDomains d2 ) {
  32                                                                                                             if ( d1
  33                                                                                                                     .getKeyDomainCount() < d2
  34                                                                                                                     .getKeyDomainCount() ) {
  35                                                                                                                 return 1;
  36                                                                                                             }
  37                                                                                                             else if ( d1
  38                                                                                                                     .getKeyDomainCount() > d2
  39                                                                                                                     .getKeyDomainCount() ) {
  40                                                                                                                 return -1;
  41                                                                                                             }
  42                                                                                                             else {
  43                                                                                                                 return d1
  44                                                                                                                         .getKeyDomain()
  45                                                                                                                         .getId()
  46                                                                                                                         .compareTo( d2
  47                                                                                                                                 .getKeyDomain()
  48                                                                                                                                 .getId() );
  49                                                                                                             }
  50                                                                                                         }
  51                                                                                                     };
  52     private static final Comparator<CombinableDomains>   DESCENDING_KEY_DOMAIN_PROTEINS_COUNT_ORDER = new Comparator<CombinableDomains>() {
  53
  54                                                                                                         public int compare( final CombinableDomains d1,
  55                                                                                                                             final CombinableDomains d2 ) {
  56                                                                                                             if ( d1
  57                                                                                                                     .getKeyDomainProteinsCount() < d2
  58                                                                                                                     .getKeyDomainProteinsCount() ) {
  59                                                                                                                 return 1;
  60                                                                                                             }
  61                                                                                                             else if ( d1
  62                                                                                                                     .getKeyDomainProteinsCount() > d2
  63                                                                                                                     .getKeyDomainProteinsCount() ) {
  64                                                                                                                 return -1;
  65                                                                                                             }
  66                                                                                                             else {
  67                                                                                                                 return d1
  68                                                                                                                         .getKeyDomain()
  69                                                                                                                         .getId()
  70                                                                                                                         .compareTo( d2
  71                                                                                                                                 .getKeyDomain()
  72                                                                                                                                 .getId() );
  73                                                                                                             }
  74                                                                                                         }
  75                                                                                                     };
  76     private static final Comparator<CombinableDomains>   DESCENDING_COMBINATIONS_COUNT_ORDER        = new Comparator<CombinableDomains>() {
  77
  78                                                                                                         public int compare( final CombinableDomains d1,
  79                                                                                                                             final CombinableDomains d2 ) {
  80                                                                                                             if ( d1
  81                                                                                                                     .getNumberOfCombinableDomains() < d2
  82                                                                                                                     .getNumberOfCombinableDomains() ) {
  83                                                                                                                 return 1;
  84                                                                                                             }
  85                                                                                                             else if ( d1
  86                                                                                                                     .getNumberOfCombinableDomains() > d2
  87                                                                                                                     .getNumberOfCombinableDomains() ) {
  88                                                                                                                 return -1;
  89                                                                                                             }
  90                                                                                                             else {
  91                                                                                                                 return d1
  92                                                                                                                         .getKeyDomain()
  93                                                                                                                         .getId()
  94                                                                                                                         .compareTo( d2
  95                                                                                                                                 .getKeyDomain()
  96                                                                                                                                 .getId() );
  97                                                                                                             }
  98                                                                                                         }
  99                                                                                                     };
 100     final private SortedMap<DomainId, CombinableDomains> _combinable_domains_map;
 101     final private Species                                _species;
 102     final private DomainCombinationType                  _dc_type;
 103
 104     private BasicGenomeWideCombinableDomains( final Species species, final DomainCombinationType dc_type ) {
 105         _combinable_domains_map = new TreeMap<DomainId, CombinableDomains>();
 106         _species = species;
 107         _dc_type = dc_type;
 108     }
 109
 110     private void add( final DomainId key, final CombinableDomains cdc ) {
 111         _combinable_domains_map.put( key, cdc );
 112     }
 113
 114     public boolean contains( final DomainId key_id ) {
 115         return _combinable_domains_map.containsKey( key_id );
 116     }
 117
 118     public CombinableDomains get( final DomainId key_id ) {
 119         return _combinable_domains_map.get( key_id );
 120     }
 121
 122     public SortedMap<DomainId, CombinableDomains> getAllCombinableDomainsIds() {
 123         return _combinable_domains_map;
 124     }
 125
 126     @Override
 127     public SortedSet<DomainId> getAllDomainIds() {
 128         final SortedSet<DomainId> domains = new TreeSet<DomainId>();
 129         for( final DomainId key : getAllCombinableDomainsIds().keySet() ) {
 130             final CombinableDomains cb = getAllCombinableDomainsIds().get( key );
 131             final List<DomainId> ds = cb.getAllDomains();
 132             for( final DomainId d : ds ) {
 133                 domains.add( d );
 134             }
 135         }
 136         return domains;
 137     }
 138
 139     @Override
 140     public DomainCombinationType getDomainCombinationType() {
 141         return _dc_type;
 142     }
 143
 144     @Override
 145     public SortedSet<DomainId> getMostPromiscuosDomain() {
 146         final SortedSet<DomainId> doms = new TreeSet<DomainId>();
 147         final int max = ( int ) getPerGenomeDomainPromiscuityStatistics().getMax();
 148         for( final DomainId key : getAllCombinableDomainsIds().keySet() ) {
 149             final CombinableDomains cb = getAllCombinableDomainsIds().get( key );
 150             if ( cb.getNumberOfCombinableDomains() == max ) {
 151                 doms.add( key );
 152             }
 153         }
 154         return doms;
 155     }
 156
 157     @Override
 158     public DescriptiveStatistics getPerGenomeDomainPromiscuityStatistics() {
 159         final DescriptiveStatistics stats = new BasicDescriptiveStatistics();
 160         for( final DomainId key : getAllCombinableDomainsIds().keySet() ) {
 161             final CombinableDomains cb = getAllCombinableDomainsIds().get( key );
 162             stats.addValue( cb.getNumberOfCombinableDomains() );
 163         }
 164         return stats;
 165     }
 166
 167     public int getSize() {
 168         return _combinable_domains_map.size();
 169     }
 170
 171     public Species getSpecies() {
 172         return _species;
 173     }
 174
 175     @Override
 176     public SortedSet<BinaryDomainCombination> toBinaryDomainCombinations() {
 177         final SortedSet<BinaryDomainCombination> binary_combinations = new TreeSet<BinaryDomainCombination>();
 178         for( final DomainId key : getAllCombinableDomainsIds().keySet() ) {
 179             final CombinableDomains cb = getAllCombinableDomainsIds().get( key );
 180             for( final BinaryDomainCombination b : cb.toBinaryDomainCombinations() ) {
 181                 binary_combinations.add( b );
 182             }
 183         }
 184         return binary_combinations;
 185     }
 186
 187     @Override
 188     public String toString() {
 189         return toStringBuilder( GenomeWideCombinableDomainsSortOrder.ALPHABETICAL_KEY_ID ).toString();
 190     }
 191
 192     // Produces something like:
 193     // 2-oxoacid_dh      5       5       2       4.8E-67   Biotin_lipoyl [4], E3_binding [3]
 194     public StringBuilder toStringBuilder( final GenomeWideCombinableDomainsSortOrder sort_order ) {
 195         final StringBuilder sb = new StringBuilder();
 196         final List<CombinableDomains> combinable_domains = new ArrayList<CombinableDomains>();
 197         for( final DomainId key : getAllCombinableDomainsIds().keySet() ) {
 198             final CombinableDomains cb = getAllCombinableDomainsIds().get( key );
 199             combinable_domains.add( cb );
 200         }
 201         if ( sort_order == GenomeWideCombinableDomainsSortOrder.KEY_DOMAIN_COUNT ) {
 202             Collections.sort( combinable_domains, BasicGenomeWideCombinableDomains.DESCENDING_KEY_DOMAIN_COUNT_ORDER );
 203         }
 204         else if ( sort_order == GenomeWideCombinableDomainsSortOrder.KEY_DOMAIN_PROTEINS_COUNT ) {
 205             Collections.sort( combinable_domains,
 206                               BasicGenomeWideCombinableDomains.DESCENDING_KEY_DOMAIN_PROTEINS_COUNT_ORDER );
 207         }
 208         else if ( sort_order == GenomeWideCombinableDomainsSortOrder.COMBINATIONS_COUNT ) {
 209             Collections.sort( combinable_domains, BasicGenomeWideCombinableDomains.DESCENDING_COMBINATIONS_COUNT_ORDER );
 210         }
 211         for( final CombinableDomains cb : combinable_domains ) {
 212             sb.append( ForesterUtil.pad( new StringBuffer( cb.getKeyDomain().toString() ), 18, ' ', false ) );
 213             sb.append( ForesterUtil.pad( new StringBuffer( "" + cb.getKeyDomainCount() ), 8, ' ', false ) );
 214             sb.append( ForesterUtil.pad( new StringBuffer( "" + cb.getKeyDomainProteinsCount() ), 8, ' ', false ) );
 215             sb.append( ForesterUtil.pad( new StringBuffer( "" + cb.getNumberOfCombinableDomains() ), 8, ' ', false ) );
 216             sb
 217                     .append( ForesterUtil
 218                             .pad( new StringBuffer( ""
 219                                           + FORMATTER
 220                                                   .format( cb.getKeyDomainConfidenceDescriptiveStatistics().median() ) ),
 221                                   10,
 222                                   ' ',
 223                                   false ) );
 224             sb.append( cb.getCombiningDomainIdsAsStringBuilder() );
 225             sb.append( ForesterUtil.getLineSeparator() );
 226         }
 227         return sb;
 228     }
 229
 230     private static void countDomains( final Map<DomainId, Integer> domain_counts,
 231                                       final Map<DomainId, Integer> domain_protein_counts,
 232                                       final Map<DomainId, DescriptiveStatistics> stats,
 233                                       final Set<DomainId> saw_c,
 234                                       final DomainId id_i,
 235                                       final double support ) {
 236         if ( domain_counts.containsKey( id_i ) ) {
 237             domain_counts.put( id_i, 1 + domain_counts.get( ( id_i ) ) );
 238             if ( !saw_c.contains( id_i ) ) {
 239                 domain_protein_counts.put( id_i, 1 + domain_protein_counts.get( ( id_i ) ) );
 240             }
 241         }
 242         else {
 243             stats.put( id_i, new BasicDescriptiveStatistics() );
 244             domain_counts.put( id_i, 1 );
 245             domain_protein_counts.put( id_i, 1 );
 246         }
 247         stats.get( id_i ).addValue( support );
 248         saw_c.add( id_i );
 249     }
 250
 251     public static BasicGenomeWideCombinableDomains createInstance( final List<Protein> protein_list,
 252                                                                    final boolean ignore_combination_with_same_domain,
 253                                                                    final Species species ) {
 254         return createInstance( protein_list,
 255                                ignore_combination_with_same_domain,
 256                                species,
 257                                null,
 258                                DomainCombinationType.BASIC );
 259     }
 260
 261     public static BasicGenomeWideCombinableDomains createInstance( final List<Protein> protein_list,
 262                                                                    final boolean ignore_combination_with_same_domain,
 263                                                                    final Species species,
 264                                                                    final DomainCombinationType dc_type ) {
 265         return createInstance( protein_list, ignore_combination_with_same_domain, species, null, dc_type );
 266     }
 267
 268     public static BasicGenomeWideCombinableDomains createInstance( final List<Protein> protein_list,
 269                                                                    final boolean ignore_combination_with_same_domain,
 270                                                                    final Species species,
 271                                                                    final Map<DomainId, List<GoId>> domain_id_to_go_ids_map,
 272                                                                    final DomainCombinationType dc_type ) {
 273         final BasicGenomeWideCombinableDomains instance = new BasicGenomeWideCombinableDomains( species, dc_type );
 274         final Map<DomainId, Integer> domain_counts = new HashMap<DomainId, Integer>();
 275         final Map<DomainId, Integer> domain_protein_counts = new HashMap<DomainId, Integer>();
 276         final Map<DomainId, DescriptiveStatistics> stats = new HashMap<DomainId, DescriptiveStatistics>();
 277         for( final Protein protein : protein_list ) {
 278             if ( !protein.getSpecies().equals( species ) ) {
 279                 throw new IllegalArgumentException( "species (" + protein.getSpecies()
 280                         + ") does not match species of combinable domains collection (" + species + ")" );
 281             }
 282             final Set<DomainId> saw_i = new HashSet<DomainId>();
 283             final Set<DomainId> saw_c = new HashSet<DomainId>();
 284             for( int i = 0; i < protein.getProteinDomains().size(); ++i ) {
 285                 final Domain pd_i = protein.getProteinDomain( i );
 286                 final DomainId id_i = pd_i.getDomainId();
 287                 final int current_start = pd_i.getFrom();
 288                 BasicGenomeWideCombinableDomains.countDomains( domain_counts,
 289                                                                domain_protein_counts,
 290                                                                stats,
 291                                                                saw_c,
 292                                                                id_i,
 293                                                                pd_i.getPerSequenceEvalue() );
 294                 if ( !saw_i.contains( id_i ) ) {
 295                     if ( dc_type == DomainCombinationType.BASIC ) {
 296                         saw_i.add( id_i );
 297                     }
 298                     CombinableDomains domain_combination = null;
 299                     if ( instance.contains( id_i ) ) {
 300                         domain_combination = instance.get( id_i );
 301                     }
 302                     else {
 303                         if ( dc_type == DomainCombinationType.DIRECTED_ADJACTANT ) {
 304                             domain_combination = new AdjactantDirectedCombinableDomains( pd_i.getDomainId(), species );
 305                         }
 306                         else if ( dc_type == DomainCombinationType.DIRECTED ) {
 307                             domain_combination = new DirectedCombinableDomains( pd_i.getDomainId(), species );
 308                         }
 309                         else {
 310                             domain_combination = new BasicCombinableDomains( pd_i.getDomainId(), species );
 311                         }
 312                         if ( ( domain_id_to_go_ids_map != null )
 313                                 && domain_id_to_go_ids_map.containsKey( pd_i.getDomainId() ) ) {
 314                             final List<GoId> go_ids = domain_id_to_go_ids_map.get( pd_i.getDomainId() );
 315                             for( final GoId go_id : go_ids ) {
 316                                 domain_combination.getKeyDomain().addGoId( go_id );
 317                             }
 318                         }
 319                         instance.add( id_i, domain_combination );
 320                     }
 321                     final Set<DomainId> saw_j = new HashSet<DomainId>();
 322                     if ( ignore_combination_with_same_domain ) {
 323                         saw_j.add( id_i );
 324                     }
 325                     Domain closest = null;
 326                     for( int j = 0; j < protein.getNumberOfProteinDomains(); ++j ) {
 327                         if ( ( dc_type != DomainCombinationType.BASIC )
 328                                 && ( current_start >= protein.getProteinDomain( j ).getFrom() ) ) {
 329                             continue;
 330                         }
 331                         if ( i != j ) {
 332                             final DomainId id = protein.getProteinDomain( j ).getDomainId();
 333                             if ( !saw_j.contains( id ) ) {
 334                                 saw_j.add( id );
 335                                 if ( dc_type != DomainCombinationType.DIRECTED_ADJACTANT ) {
 336                                     domain_combination
 337                                             .addCombinableDomain( protein.getProteinDomain( j ).getDomainId() );
 338                                 }
 339                                 else {
 340                                     if ( closest == null ) {
 341                                         closest = protein.getProteinDomain( j );
 342                                     }
 343                                     else {
 344                                         if ( protein.getProteinDomain( j ).getFrom() < closest.getFrom() ) {
 345                                             closest = protein.getProteinDomain( j );
 346                                         }
 347                                     }
 348                                 }
 349                             }
 350                         }
 351                     }
 352                     if ( ( dc_type == DomainCombinationType.DIRECTED_ADJACTANT ) && ( closest != null ) ) {
 353                         domain_combination.addCombinableDomain( closest.getDomainId() );
 354                     }
 355                 }
 356             }
 357         }
 358         for( final DomainId key_id : domain_counts.keySet() ) {
 359             instance.get( key_id ).setKeyDomainCount( domain_counts.get( key_id ) );
 360             instance.get( key_id ).setKeyDomainProteinsCount( domain_protein_counts.get( key_id ) );
 361             instance.get( key_id ).setKeyDomainConfidenceDescriptiveStatistics( stats.get( key_id ) );
 362         }
 363         return instance;
 364     }
 365 }