forester/java/src/org/forester/surfacing/MinimalDomainomeCalculator.java

   1
   2 package org.forester.surfacing;
   3
   4 import java.io.BufferedWriter;
   5 import java.io.File;
   6 import java.io.FileWriter;
   7 import java.io.IOException;
   8 import java.io.Writer;
   9 import java.util.ArrayList;
  10 import java.util.Arrays;
  11 import java.util.HashSet;
  12 import java.util.List;
  13 import java.util.Map.Entry;
  14 import java.util.Set;
  15 import java.util.SortedMap;
  16 import java.util.SortedSet;
  17 import java.util.TreeMap;
  18 import java.util.TreeSet;
  19
  20 import org.forester.application.surfacing;
  21 import org.forester.phylogeny.Phylogeny;
  22 import org.forester.phylogeny.PhylogenyMethods;
  23 import org.forester.phylogeny.PhylogenyNode;
  24 import org.forester.phylogeny.iterators.PhylogenyNodeIterator;
  25 import org.forester.protein.Domain;
  26 import org.forester.protein.Protein;
  27 import org.forester.species.BasicSpecies;
  28 import org.forester.species.Species;
  29 import org.forester.surfacing.SurfacingUtil.DomainComparator;
  30 import org.forester.util.ForesterUtil;
  31
  32 public final class MinimalDomainomeCalculator {
  33
  34     public final static void calc( final boolean use_domain_architectures,
  35                                    final Phylogeny tre,
  36                                    final SortedMap<Species, List<Protein>> protein_lists_per_species,
  37                                    final String separator,
  38                                    final double ie_cutoff,
  39                                    final String outfile_base,
  40                                    final boolean write_protein_files )
  41             throws IOException {
  42         final SortedMap<String, SortedSet<String>> species_to_features_map = new TreeMap<String, SortedSet<String>>();
  43         if ( protein_lists_per_species == null || tre == null ) {
  44             throw new IllegalArgumentException( "argument is null" );
  45         }
  46         if ( protein_lists_per_species.size() < 2 ) {
  47             throw new IllegalArgumentException( "not enough genomes" );
  48         }
  49         final String x;
  50         if ( use_domain_architectures ) {
  51             x = "DA";
  52         }
  53         else {
  54             x = "domain";
  55         }
  56         final File outfile = new File( outfile_base + "_minimal_" + x + "ome.tsv" );
  57         final File outfile_table = new File( outfile_base + "_minimal_" + x + "ome_matrix.tsv" );
  58         SurfacingUtil.checkForOutputFileWriteability( outfile );
  59         SurfacingUtil.checkForOutputFileWriteability( outfile_table );
  60         final BufferedWriter out = new BufferedWriter( new FileWriter( outfile ) );
  61         final BufferedWriter out_table = new BufferedWriter( new FileWriter( outfile_table ) );
  62         out.write( "SPECIES\tCOMMON NAME\tCODE\tRANK\t#EXT NODES\tEXT NODE CODES\t#" + x + "\t" + x + "" );
  63         out.write( ForesterUtil.LINE_SEPARATOR );
  64         for( final PhylogenyNodeIterator iter = tre.iteratorPostorder(); iter.hasNext(); ) {
  65             final PhylogenyNode node = iter.next();
  66             final String species_name = node.getNodeData().isHasTaxonomy()
  67                     ? node.getNodeData().getTaxonomy().getScientificName() : node.getName();
  68             final String common = node.getNodeData().isHasTaxonomy() ? node.getNodeData().getTaxonomy().getCommonName()
  69                     : "";
  70             final String tcode = node.getNodeData().isHasTaxonomy() ? node.getNodeData().getTaxonomy().getTaxonomyCode()
  71                     : "";
  72             final String rank = node.getNodeData().isHasTaxonomy() ? node.getNodeData().getTaxonomy().getRank() : "";
  73             out.write( species_name );
  74             if ( !ForesterUtil.isEmpty( common ) ) {
  75                 out.write( "\t" + common );
  76             }
  77             else {
  78                 out.write( "\t" );
  79             }
  80             if ( !ForesterUtil.isEmpty( tcode ) ) {
  81                 out.write( "\t" + tcode );
  82             }
  83             else {
  84                 out.write( "\t" );
  85             }
  86             if ( !ForesterUtil.isEmpty( rank ) ) {
  87                 out.write( "\t" + rank );
  88             }
  89             else {
  90                 out.write( "\t" );
  91             }
  92             final List<PhylogenyNode> external_descs = node.getAllExternalDescendants();
  93             if ( node.isInternal() ) {
  94                 out.write( "\t" + external_descs.size() + "\t" );
  95             }
  96             else {
  97                 out.write( "\t\t" );
  98             }
  99             final List<Set<String>> features_per_genome_list = new ArrayList<Set<String>>();
 100             boolean first = true;
 101             for( final PhylogenyNode external_desc : external_descs ) {
 102                 final String code = external_desc.getNodeData().getTaxonomy().getTaxonomyCode();
 103                 if ( node.isInternal() ) {
 104                     if ( first ) {
 105                         first = false;
 106                     }
 107                     else {
 108                         out.write( ", " );
 109                     }
 110                     out.write( code );
 111                 }
 112                 final List<Protein> proteins_per_species = protein_lists_per_species.get( new BasicSpecies( code ) );
 113                 if ( proteins_per_species != null ) {
 114                     final SortedSet<String> features_per_genome = new TreeSet<String>();
 115                     for( final Protein protein : proteins_per_species ) {
 116                         if ( use_domain_architectures ) {
 117                             final String da = protein.toDomainArchitectureString( separator, ie_cutoff );
 118                             features_per_genome.add( da );
 119                         }
 120                         else {
 121                             List<Domain> domains = protein.getProteinDomains();
 122                             for( final Domain domain : domains ) {
 123                                 if ( ( ie_cutoff <= -1 ) || ( domain.getPerDomainEvalue() <= ie_cutoff ) ) {
 124                                     features_per_genome.add( domain.getDomainId() );
 125                                 }
 126                             }
 127                         }
 128                     }
 129                     if ( features_per_genome.size() > 0 ) {
 130                         features_per_genome_list.add( features_per_genome );
 131                     }
 132                 }
 133             }
 134             if ( features_per_genome_list.size() > 0 ) {
 135                 SortedSet<String> intersection = calcIntersection( features_per_genome_list );
 136                 out.write( "\t" + intersection.size() + "\t" );
 137                 first = true;
 138                 for( final String s : intersection ) {
 139                     if ( first ) {
 140                         first = false;
 141                     }
 142                     else {
 143                         out.write( ", " );
 144                     }
 145                     out.write( s );
 146                 }
 147                 out.write( ForesterUtil.LINE_SEPARATOR );
 148                 species_to_features_map.put( species_name, intersection );
 149             }
 150         }
 151         final SortedSet<String> all_species_names = new TreeSet<String>();
 152         final SortedSet<String> all_features = new TreeSet<String>();
 153         for( final Entry<String, SortedSet<String>> e : species_to_features_map.entrySet() ) {
 154             all_species_names.add( e.getKey() );
 155             for( final String f : e.getValue() ) {
 156                 all_features.add( f );
 157             }
 158         }
 159         out_table.write( '\t' );
 160         boolean first = true;
 161         for( final String species_name : all_species_names ) {
 162             if ( first ) {
 163                 first = false;
 164             }
 165             else {
 166                 out_table.write( '\t' );
 167             }
 168             out_table.write( species_name );
 169         }
 170         out_table.write( ForesterUtil.LINE_SEPARATOR );
 171         for( final String das : all_features ) {
 172             out_table.write( das );
 173             out_table.write( '\t' );
 174             first = true;
 175             for( final String species_name : all_species_names ) {
 176                 if ( first ) {
 177                     first = false;
 178                 }
 179                 else {
 180                     out_table.write( '\t' );
 181                 }
 182                 if ( species_to_features_map.get( species_name ).contains( das ) ) {
 183                     out_table.write( '1' );
 184                 }
 185                 else {
 186                     out_table.write( '0' );
 187                 }
 188             }
 189             out_table.write( ForesterUtil.LINE_SEPARATOR );
 190         }
 191         out.flush();
 192         out.close();
 193         out_table.flush();
 194         out_table.close();
 195         ForesterUtil.programMessage( surfacing.PRG_NAME, "Wrote minimal DAome data to           : " + outfile );
 196         ForesterUtil.programMessage( surfacing.PRG_NAME, "Wrote minimal DAome data to (as table): " + outfile_table );
 197         if ( write_protein_files ) {
 198             final String protdirname;
 199             final String a;
 200             final String b;
 201             if ( use_domain_architectures ) {
 202                 a = "_DA";
 203                 b = "domain architectures (DAs)";
 204                 protdirname = "_DAS";
 205             }
 206             else {
 207                 a = "_domain";
 208                 b = "domains";
 209                 protdirname = "_DOMAINS";
 210             }
 211             final File prot_dir = new File( outfile_base + protdirname );
 212             final boolean success = prot_dir.mkdir();
 213             if ( !success ) {
 214                 throw new IOException( "failed to create dir " + prot_dir );
 215             }
 216             int total = 0;
 217             final String dir = outfile_base + protdirname + "/";
 218             for( final String feat : all_features ) {
 219                 final File extract_outfile = new File( dir + feat + a + surfacing.SEQ_EXTRACT_SUFFIX );
 220                 SurfacingUtil.checkForOutputFileWriteability( extract_outfile );
 221                 final Writer proteins_file_writer = new BufferedWriter( new FileWriter( extract_outfile ) );
 222                 final int counter = extractProteinFeatures( use_domain_architectures,
 223                                                             protein_lists_per_species,
 224                                                             feat,
 225                                                             proteins_file_writer,
 226                                                             ie_cutoff,
 227                                                             separator );
 228                 if ( counter < 1 ) {
 229                     ForesterUtil.printWarningMessage( "surfacing", feat + " not present (in " + b + " extraction)" );
 230                 }
 231                 total += counter;
 232                 proteins_file_writer.close();
 233             }
 234             ForesterUtil.programMessage( "surfacing",
 235                                          "Wrote " + total + " individual " + b + " from a total of "
 236                                                  + all_features.size() + " into: " + dir );
 237         }
 238     }
 239
 240     public final static void calcNEW( final boolean use_domain_architectures,
 241                                       final Phylogeny tre,
 242                                       final int level,
 243                                       final SortedMap<Species, List<Protein>> protein_lists_per_species,
 244                                       final String separator,
 245                                       final double ie_cutoff,
 246                                       final String outfile_base,
 247                                       final boolean write_protein_files )
 248             throws IOException {
 249         final SortedMap<String, SortedSet<String>> species_to_features_map = new TreeMap<String, SortedSet<String>>();
 250         if ( protein_lists_per_species == null || tre == null ) {
 251             throw new IllegalArgumentException( "argument is null" );
 252         }
 253         if ( protein_lists_per_species.size() < 2 ) {
 254             throw new IllegalArgumentException( "not enough genomes" );
 255         }
 256         final String x;
 257         if ( use_domain_architectures ) {
 258             x = "DA";
 259         }
 260         else {
 261             x = "domain";
 262         }
 263         final File outfile = new File( outfile_base + "_minimal_" + x + "ome.tsv" );
 264         final File outfile_table = new File( outfile_base + "_minimal_" + x + "ome_matrix.tsv" );
 265         SurfacingUtil.checkForOutputFileWriteability( outfile );
 266         SurfacingUtil.checkForOutputFileWriteability( outfile_table );
 267         final BufferedWriter out = new BufferedWriter( new FileWriter( outfile ) );
 268         final BufferedWriter out_table = new BufferedWriter( new FileWriter( outfile_table ) );
 269         out.write( "SPECIES\tCOMMON NAME\tCODE\tRANK\t#EXT NODES\tEXT NODE CODES\t#" + x + "\t" + x + "" );
 270         out.write( ForesterUtil.LINE_SEPARATOR );
 271         ///////////
 272         //////////
 273         SortedMap<String, List<Protein>> protein_lists_per_quasi_species = null;
 274         if ( level >= 1 ) {
 275             protein_lists_per_quasi_species = makeProteinListsPerQuasiSpecies( tre, level, protein_lists_per_species );
 276         }
 277         /////////
 278         ///////////
 279         for( final PhylogenyNodeIterator iter = tre.iteratorPostorder(); iter.hasNext(); ) {
 280             final PhylogenyNode node = iter.next();
 281             final String species_name = node.getNodeData().isHasTaxonomy()
 282                     ? node.getNodeData().getTaxonomy().getScientificName() : node.getName();
 283             final String common = node.getNodeData().isHasTaxonomy() ? node.getNodeData().getTaxonomy().getCommonName()
 284                     : "";
 285             final String tcode = node.getNodeData().isHasTaxonomy() ? node.getNodeData().getTaxonomy().getTaxonomyCode()
 286                     : "";
 287             final String rank = node.getNodeData().isHasTaxonomy() ? node.getNodeData().getTaxonomy().getRank() : "";
 288             out.write( species_name );
 289             if ( !ForesterUtil.isEmpty( common ) ) {
 290                 out.write( "\t" + common );
 291             }
 292             else {
 293                 out.write( "\t" );
 294             }
 295             if ( !ForesterUtil.isEmpty( tcode ) ) {
 296                 out.write( "\t" + tcode );
 297             }
 298             else {
 299                 out.write( "\t" );
 300             }
 301             if ( !ForesterUtil.isEmpty( rank ) ) {
 302                 out.write( "\t" + rank );
 303             }
 304             else {
 305                 out.write( "\t" );
 306             }
 307             final List<PhylogenyNode> external_descs = node.getAllExternalDescendants();
 308             if ( node.isInternal() ) {
 309                 out.write( "\t" + external_descs.size() + "\t" );
 310             }
 311             else {
 312                 out.write( "\t\t" );
 313             }
 314             final List<Set<String>> features_per_genome_list = new ArrayList<Set<String>>();
 315             boolean first = true;
 316             if ( level >= 1 ) {
 317                 ////////////
 318                 ////////////
 319                 final int node_level = PhylogenyMethods.calculateLevel( node );
 320                 if ( node_level >= level ) {
 321                     final List<PhylogenyNode> given_level_descs = PhylogenyMethods
 322                             .getAllDescendantsOfGivenLevel( node, level );
 323                     for( final PhylogenyNode given_level_desc : given_level_descs ) {
 324                         final String spec_name = given_level_desc.getNodeData().isHasTaxonomy()
 325                                 ? given_level_desc.getNodeData().getTaxonomy().getScientificName() : given_level_desc.getName();
 326                     }
 327                 }
 328                 ///////////
 329                 ///////////
 330             }
 331             else {
 332                 for( final PhylogenyNode external_desc : external_descs ) {
 333                     final String code = external_desc.getNodeData().getTaxonomy().getTaxonomyCode();
 334                     if ( node.isInternal() ) {
 335                         if ( first ) {
 336                             first = false;
 337                         }
 338                         else {
 339                             out.write( ", " );
 340                         }
 341                         out.write( code );
 342                     }
 343                     final List<Protein> proteins_per_species = protein_lists_per_species
 344                             .get( new BasicSpecies( code ) );
 345                     if ( proteins_per_species != null ) {
 346                         final SortedSet<String> features_per_genome = new TreeSet<String>();
 347                         for( final Protein protein : proteins_per_species ) {
 348                             if ( use_domain_architectures ) {
 349                                 final String da = protein.toDomainArchitectureString( separator, ie_cutoff );
 350                                 features_per_genome.add( da );
 351                             }
 352                             else {
 353                                 List<Domain> domains = protein.getProteinDomains();
 354                                 for( final Domain domain : domains ) {
 355                                     if ( ( ie_cutoff <= -1 ) || ( domain.getPerDomainEvalue() <= ie_cutoff ) ) {
 356                                         features_per_genome.add( domain.getDomainId() );
 357                                     }
 358                                 }
 359                             }
 360                         }
 361                         if ( features_per_genome.size() > 0 ) {
 362                             features_per_genome_list.add( features_per_genome );
 363                         }
 364                     }
 365                 } // for( final PhylogenyNode external_desc : external_descs )
 366             } // else
 367             if ( features_per_genome_list.size() > 0 ) {
 368                 SortedSet<String> intersection = calcIntersection( features_per_genome_list );
 369                 out.write( "\t" + intersection.size() + "\t" );
 370                 first = true;
 371                 for( final String s : intersection ) {
 372                     if ( first ) {
 373                         first = false;
 374                     }
 375                     else {
 376                         out.write( ", " );
 377                     }
 378                     out.write( s );
 379                 }
 380                 out.write( ForesterUtil.LINE_SEPARATOR );
 381                 species_to_features_map.put( species_name, intersection );
 382             }
 383         }
 384         final SortedSet<String> all_species_names = new TreeSet<String>();
 385         final SortedSet<String> all_features = new TreeSet<String>();
 386         for( final Entry<String, SortedSet<String>> e : species_to_features_map.entrySet() ) {
 387             all_species_names.add( e.getKey() );
 388             for( final String f : e.getValue() ) {
 389                 all_features.add( f );
 390             }
 391         }
 392         out_table.write( '\t' );
 393         boolean first = true;
 394         for( final String species_name : all_species_names ) {
 395             if ( first ) {
 396                 first = false;
 397             }
 398             else {
 399                 out_table.write( '\t' );
 400             }
 401             out_table.write( species_name );
 402         }
 403         out_table.write( ForesterUtil.LINE_SEPARATOR );
 404         for( final String das : all_features ) {
 405             out_table.write( das );
 406             out_table.write( '\t' );
 407             first = true;
 408             for( final String species_name : all_species_names ) {
 409                 if ( first ) {
 410                     first = false;
 411                 }
 412                 else {
 413                     out_table.write( '\t' );
 414                 }
 415                 if ( species_to_features_map.get( species_name ).contains( das ) ) {
 416                     out_table.write( '1' );
 417                 }
 418                 else {
 419                     out_table.write( '0' );
 420                 }
 421             }
 422             out_table.write( ForesterUtil.LINE_SEPARATOR );
 423         }
 424         out.flush();
 425         out.close();
 426         out_table.flush();
 427         out_table.close();
 428         ForesterUtil.programMessage( surfacing.PRG_NAME, "Wrote minimal DAome data to           : " + outfile );
 429         ForesterUtil.programMessage( surfacing.PRG_NAME, "Wrote minimal DAome data to (as table): " + outfile_table );
 430         if ( write_protein_files ) {
 431             final String protdirname;
 432             final String a;
 433             final String b;
 434             if ( use_domain_architectures ) {
 435                 a = "_DA";
 436                 b = "domain architectures (DAs)";
 437                 protdirname = "_DAS";
 438             }
 439             else {
 440                 a = "_domain";
 441                 b = "domains";
 442                 protdirname = "_DOMAINS";
 443             }
 444             final File prot_dir = new File( outfile_base + protdirname );
 445             final boolean success = prot_dir.mkdir();
 446             if ( !success ) {
 447                 throw new IOException( "failed to create dir " + prot_dir );
 448             }
 449             int total = 0;
 450             final String dir = outfile_base + protdirname + "/";
 451             for( final String feat : all_features ) {
 452                 final File extract_outfile = new File( dir + feat + a + surfacing.SEQ_EXTRACT_SUFFIX );
 453                 SurfacingUtil.checkForOutputFileWriteability( extract_outfile );
 454                 final Writer proteins_file_writer = new BufferedWriter( new FileWriter( extract_outfile ) );
 455                 final int counter = extractProteinFeatures( use_domain_architectures,
 456                                                             protein_lists_per_species,
 457                                                             feat,
 458                                                             proteins_file_writer,
 459                                                             ie_cutoff,
 460                                                             separator );
 461                 if ( counter < 1 ) {
 462                     ForesterUtil.printWarningMessage( "surfacing", feat + " not present (in " + b + " extraction)" );
 463                 }
 464                 total += counter;
 465                 proteins_file_writer.close();
 466             }
 467             ForesterUtil.programMessage( "surfacing",
 468                                          "Wrote " + total + " individual " + b + " from a total of "
 469                                                  + all_features.size() + " into: " + dir );
 470         }
 471     }
 472
 473     private final static SortedMap<String, List<Protein>> makeProteinListsPerQuasiSpecies( final Phylogeny tre,
 474                                                                                            final int level,
 475                                                                                            final SortedMap<Species, List<Protein>> protein_lists_per_species ) {
 476         final SortedMap<String, List<Protein>> protein_lists_per_quasi_species = new TreeMap<String, List<Protein>>();
 477         for( final PhylogenyNodeIterator iter = tre.iteratorPostorder(); iter.hasNext(); ) {
 478             final PhylogenyNode node = iter.next();
 479             final int node_level = PhylogenyMethods.calculateLevel( node );
 480             if ( node_level == level ) {
 481                 final List<PhylogenyNode> external_descs = node.getAllExternalDescendants();
 482                 final List<Protein> protein_list_per_quasi_species = new ArrayList<Protein>();
 483                 for( final PhylogenyNode external_desc : external_descs ) {
 484                     final String code = external_desc.getNodeData().getTaxonomy().getTaxonomyCode();
 485                     final List<Protein> proteins_per_species = protein_lists_per_species
 486                             .get( new BasicSpecies( code ) );
 487                     for( Protein protein : proteins_per_species ) {
 488                         protein_list_per_quasi_species.add( protein );
 489                     }
 490                 }
 491                 final String species_name = node.getNodeData().isHasTaxonomy()
 492                         ? node.getNodeData().getTaxonomy().getScientificName() : node.getName();
 493                 protein_lists_per_quasi_species.put( species_name, protein_list_per_quasi_species );
 494             }
 495         }
 496         return protein_lists_per_quasi_species;
 497     }
 498
 499     private final static SortedSet<String> calcIntersection( final List<Set<String>> features_per_genome_list ) {
 500         final Set<String> first = features_per_genome_list.get( 0 );
 501         final SortedSet<String> my_first = new TreeSet<String>();
 502         for( final String s : first ) {
 503             my_first.add( s );
 504         }
 505         for( int i = 1; i < features_per_genome_list.size(); ++i ) {
 506             my_first.retainAll( features_per_genome_list.get( i ) );
 507         }
 508         return my_first;
 509     }
 510
 511     private final static int extractProteinFeatures( final boolean use_domain_architectures,
 512                                                      final SortedMap<Species, List<Protein>> protein_lists_per_species,
 513                                                      final String domain_id,
 514                                                      final Writer out,
 515                                                      final double ie_cutoff,
 516                                                      final String domain_separator )
 517             throws IOException {
 518         int counter = 0;
 519         final String separator_for_output = "\t";
 520         for( final Species species : protein_lists_per_species.keySet() ) {
 521             final List<Protein> proteins_per_species = protein_lists_per_species.get( species );
 522             for( final Protein protein : proteins_per_species ) {
 523                 if ( use_domain_architectures ) {
 524                     if ( domain_id.equals( protein.toDomainArchitectureString( domain_separator, ie_cutoff ) ) ) {
 525                         int from = Integer.MAX_VALUE;
 526                         int to = -1;
 527                         for( final Domain d : protein.getProteinDomains() ) {
 528                             if ( ( ie_cutoff <= -1 ) || ( d.getPerDomainEvalue() <= ie_cutoff ) ) {
 529                                 if ( d.getFrom() < from ) {
 530                                     from = d.getFrom();
 531                                 }
 532                                 if ( d.getTo() > to ) {
 533                                     to = d.getTo();
 534                                 }
 535                             }
 536                         }
 537                         out.write( protein.getSpecies().getSpeciesId() );
 538                         out.write( separator_for_output );
 539                         out.write( protein.getProteinId().getId() );
 540                         out.write( separator_for_output );
 541                         out.write( domain_id );
 542                         out.write( separator_for_output );
 543                         out.write( "/" );
 544                         out.write( from + "-" + to );
 545                         out.write( "/" );
 546                         out.write( SurfacingConstants.NL );
 547                         ++counter;
 548                     }
 549                 }
 550                 else {
 551                     final List<Domain> domains = protein.getProteinDomains( domain_id );
 552                     if ( domains.size() > 0 ) {
 553                         out.write( protein.getSpecies().getSpeciesId() );
 554                         out.write( separator_for_output );
 555                         out.write( protein.getProteinId().getId() );
 556                         out.write( separator_for_output );
 557                         out.write( domain_id );
 558                         out.write( separator_for_output );
 559                         for( final Domain domain : domains ) {
 560                             if ( ( ie_cutoff < 0 ) || ( domain.getPerDomainEvalue() <= ie_cutoff ) ) {
 561                                 out.write( "/" );
 562                                 out.write( domain.getFrom() + "-" + domain.getTo() );
 563                             }
 564                         }
 565                         out.write( "/" );
 566                         out.write( separator_for_output );
 567                         final List<Domain> domain_list = new ArrayList<Domain>();
 568                         for( final Domain domain : protein.getProteinDomains() ) {
 569                             if ( ( ie_cutoff < 0 ) || ( domain.getPerDomainEvalue() <= ie_cutoff ) ) {
 570                                 domain_list.add( domain );
 571                             }
 572                         }
 573                         final Domain domain_ary[] = new Domain[ domain_list.size() ];
 574                         for( int i = 0; i < domain_list.size(); ++i ) {
 575                             domain_ary[ i ] = domain_list.get( i );
 576                         }
 577                         Arrays.sort( domain_ary, new DomainComparator( true ) );
 578                         out.write( "{" );
 579                         boolean first = true;
 580                         for( final Domain domain : domain_ary ) {
 581                             if ( first ) {
 582                                 first = false;
 583                             }
 584                             else {
 585                                 out.write( "," );
 586                             }
 587                             out.write( domain.getDomainId().toString() );
 588                             out.write( ":" + domain.getFrom() + "-" + domain.getTo() );
 589                             out.write( ":" + domain.getPerDomainEvalue() );
 590                         }
 591                         out.write( "}" );
 592                         if ( !( ForesterUtil.isEmpty( protein.getDescription() )
 593                                 || protein.getDescription().equals( SurfacingConstants.NONE ) ) ) {
 594                             out.write( protein.getDescription() );
 595                         }
 596                         out.write( separator_for_output );
 597                         if ( !( ForesterUtil.isEmpty( protein.getAccession() )
 598                                 || protein.getAccession().equals( SurfacingConstants.NONE ) ) ) {
 599                             out.write( protein.getAccession() );
 600                         }
 601                         out.write( SurfacingConstants.NL );
 602                         ++counter;
 603                     }
 604                 }
 605             }
 606         }
 607         out.flush();
 608         return counter;
 609     }
 610
 611     public static void main( final String[] args ) {
 612         Set<String> a = new HashSet<String>();
 613         Set<String> b = new HashSet<String>();
 614         Set<String> c = new HashSet<String>();
 615         Set<String> d = new HashSet<String>();
 616         a.add( "x" );
 617         a.add( "b" );
 618         a.add( "c" );
 619         b.add( "a" );
 620         b.add( "b" );
 621         b.add( "c" );
 622         c.add( "a" );
 623         c.add( "b" );
 624         c.add( "c" );
 625         c.add( "c" );
 626         c.add( "f" );
 627         d.add( "a" );
 628         d.add( "c" );
 629         d.add( "d" );
 630         List<Set<String>> domains_per_genome_list = new ArrayList<Set<String>>();
 631         domains_per_genome_list.add( a );
 632         domains_per_genome_list.add( b );
 633         domains_per_genome_list.add( c );
 634         domains_per_genome_list.add( d );
 635         Set<String> x = calcIntersection( domains_per_genome_list );
 636         System.out.println( x );
 637     }
 638 }