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