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             for( final PhylogenyNode external_desc : external_descs ) {
 317                 final String code = external_desc.getNodeData().getTaxonomy().getTaxonomyCode();
 318                 if ( node.isInternal() ) {
 319                     if ( first ) {
 320                         first = false;
 321                     }
 322                     else {
 323                         out.write( ", " );
 324                     }
 325                     out.write( code );
 326                 }
 327                 final List<Protein> proteins_per_species = protein_lists_per_species.get( new BasicSpecies( code ) );
 328                 final int node_level = PhylogenyMethods.calculateLevel( node );
 329                 final List<Protein> proteins_per_quasi_species = protein_lists_per_species
 330                         .get( new BasicSpecies( code ) );
 331                 if ( proteins_per_species != null ) {
 332                     final SortedSet<String> features_per_genome = new TreeSet<String>();
 333                     for( final Protein protein : proteins_per_species ) {
 334                         if ( use_domain_architectures ) {
 335                             final String da = protein.toDomainArchitectureString( separator, ie_cutoff );
 336                             features_per_genome.add( da );
 337                         }
 338                         else {
 339                             List<Domain> domains = protein.getProteinDomains();
 340                             for( final Domain domain : domains ) {
 341                                 if ( ( ie_cutoff <= -1 ) || ( domain.getPerDomainEvalue() <= ie_cutoff ) ) {
 342                                     features_per_genome.add( domain.getDomainId() );
 343                                 }
 344                             }
 345                         }
 346                     }
 347                     if ( features_per_genome.size() > 0 ) {
 348                         features_per_genome_list.add( features_per_genome );
 349                     }
 350                 }
 351             } // for( final PhylogenyNode external_desc : external_descs )
 352             if ( features_per_genome_list.size() > 0 ) {
 353                 SortedSet<String> intersection = calcIntersection( features_per_genome_list );
 354                 out.write( "\t" + intersection.size() + "\t" );
 355                 first = true;
 356                 for( final String s : intersection ) {
 357                     if ( first ) {
 358                         first = false;
 359                     }
 360                     else {
 361                         out.write( ", " );
 362                     }
 363                     out.write( s );
 364                 }
 365                 out.write( ForesterUtil.LINE_SEPARATOR );
 366                 species_to_features_map.put( species_name, intersection );
 367             }
 368         }
 369         final SortedSet<String> all_species_names = new TreeSet<String>();
 370         final SortedSet<String> all_features = new TreeSet<String>();
 371         for( final Entry<String, SortedSet<String>> e : species_to_features_map.entrySet() ) {
 372             all_species_names.add( e.getKey() );
 373             for( final String f : e.getValue() ) {
 374                 all_features.add( f );
 375             }
 376         }
 377         out_table.write( '\t' );
 378         boolean first = true;
 379         for( final String species_name : all_species_names ) {
 380             if ( first ) {
 381                 first = false;
 382             }
 383             else {
 384                 out_table.write( '\t' );
 385             }
 386             out_table.write( species_name );
 387         }
 388         out_table.write( ForesterUtil.LINE_SEPARATOR );
 389         for( final String das : all_features ) {
 390             out_table.write( das );
 391             out_table.write( '\t' );
 392             first = true;
 393             for( final String species_name : all_species_names ) {
 394                 if ( first ) {
 395                     first = false;
 396                 }
 397                 else {
 398                     out_table.write( '\t' );
 399                 }
 400                 if ( species_to_features_map.get( species_name ).contains( das ) ) {
 401                     out_table.write( '1' );
 402                 }
 403                 else {
 404                     out_table.write( '0' );
 405                 }
 406             }
 407             out_table.write( ForesterUtil.LINE_SEPARATOR );
 408         }
 409         out.flush();
 410         out.close();
 411         out_table.flush();
 412         out_table.close();
 413         ForesterUtil.programMessage( surfacing.PRG_NAME, "Wrote minimal DAome data to           : " + outfile );
 414         ForesterUtil.programMessage( surfacing.PRG_NAME, "Wrote minimal DAome data to (as table): " + outfile_table );
 415         if ( write_protein_files ) {
 416             final String protdirname;
 417             final String a;
 418             final String b;
 419             if ( use_domain_architectures ) {
 420                 a = "_DA";
 421                 b = "domain architectures (DAs)";
 422                 protdirname = "_DAS";
 423             }
 424             else {
 425                 a = "_domain";
 426                 b = "domains";
 427                 protdirname = "_DOMAINS";
 428             }
 429             final File prot_dir = new File( outfile_base + protdirname );
 430             final boolean success = prot_dir.mkdir();
 431             if ( !success ) {
 432                 throw new IOException( "failed to create dir " + prot_dir );
 433             }
 434             int total = 0;
 435             final String dir = outfile_base + protdirname + "/";
 436             for( final String feat : all_features ) {
 437                 final File extract_outfile = new File( dir + feat + a + surfacing.SEQ_EXTRACT_SUFFIX );
 438                 SurfacingUtil.checkForOutputFileWriteability( extract_outfile );
 439                 final Writer proteins_file_writer = new BufferedWriter( new FileWriter( extract_outfile ) );
 440                 final int counter = extractProteinFeatures( use_domain_architectures,
 441                                                             protein_lists_per_species,
 442                                                             feat,
 443                                                             proteins_file_writer,
 444                                                             ie_cutoff,
 445                                                             separator );
 446                 if ( counter < 1 ) {
 447                     ForesterUtil.printWarningMessage( "surfacing", feat + " not present (in " + b + " extraction)" );
 448                 }
 449                 total += counter;
 450                 proteins_file_writer.close();
 451             }
 452             ForesterUtil.programMessage( "surfacing",
 453                                          "Wrote " + total + " individual " + b + " from a total of "
 454                                                  + all_features.size() + " into: " + dir );
 455         }
 456     }
 457
 458     private final static SortedMap<String, List<Protein>> makeProteinListsPerQuasiSpecies( final Phylogeny tre,
 459                                                                                            final int level,
 460                                                                                            final SortedMap<Species, List<Protein>> protein_lists_per_species ) {
 461         final SortedMap<String, List<Protein>> protein_lists_per_quasi_species = new TreeMap<String, List<Protein>>();
 462         for( final PhylogenyNodeIterator iter = tre.iteratorPostorder(); iter.hasNext(); ) {
 463             final PhylogenyNode node = iter.next();
 464             final int node_level = PhylogenyMethods.calculateLevel( node );
 465             if ( node_level == level ) {
 466                 final List<PhylogenyNode> external_descs = node.getAllExternalDescendants();
 467                 final List<Protein> protein_list_per_quasi_species = new ArrayList<Protein>();
 468                 for( final PhylogenyNode external_desc : external_descs ) {
 469                     final String code = external_desc.getNodeData().getTaxonomy().getTaxonomyCode();
 470                     final List<Protein> proteins_per_species = protein_lists_per_species
 471                             .get( new BasicSpecies( code ) );
 472                     for( Protein protein : proteins_per_species ) {
 473                         protein_list_per_quasi_species.add( protein );
 474                     }
 475                 }
 476                 final String species_name = node.getNodeData().isHasTaxonomy()
 477                         ? node.getNodeData().getTaxonomy().getScientificName() : node.getName();
 478                 protein_lists_per_quasi_species.put( species_name, protein_list_per_quasi_species );
 479             }
 480         }
 481         return protein_lists_per_quasi_species;
 482     }
 483
 484     private final static SortedSet<String> calcIntersection( final List<Set<String>> features_per_genome_list ) {
 485         final Set<String> first = features_per_genome_list.get( 0 );
 486         final SortedSet<String> my_first = new TreeSet<String>();
 487         for( final String s : first ) {
 488             my_first.add( s );
 489         }
 490         for( int i = 1; i < features_per_genome_list.size(); ++i ) {
 491             my_first.retainAll( features_per_genome_list.get( i ) );
 492         }
 493         return my_first;
 494     }
 495
 496     private final static int extractProteinFeatures( final boolean use_domain_architectures,
 497                                                      final SortedMap<Species, List<Protein>> protein_lists_per_species,
 498                                                      final String domain_id,
 499                                                      final Writer out,
 500                                                      final double ie_cutoff,
 501                                                      final String domain_separator )
 502             throws IOException {
 503         int counter = 0;
 504         final String separator_for_output = "\t";
 505         for( final Species species : protein_lists_per_species.keySet() ) {
 506             final List<Protein> proteins_per_species = protein_lists_per_species.get( species );
 507             for( final Protein protein : proteins_per_species ) {
 508                 if ( use_domain_architectures ) {
 509                     if ( domain_id.equals( protein.toDomainArchitectureString( domain_separator, ie_cutoff ) ) ) {
 510                         int from = Integer.MAX_VALUE;
 511                         int to = -1;
 512                         for( final Domain d : protein.getProteinDomains() ) {
 513                             if ( ( ie_cutoff <= -1 ) || ( d.getPerDomainEvalue() <= ie_cutoff ) ) {
 514                                 if ( d.getFrom() < from ) {
 515                                     from = d.getFrom();
 516                                 }
 517                                 if ( d.getTo() > to ) {
 518                                     to = d.getTo();
 519                                 }
 520                             }
 521                         }
 522                         out.write( protein.getSpecies().getSpeciesId() );
 523                         out.write( separator_for_output );
 524                         out.write( protein.getProteinId().getId() );
 525                         out.write( separator_for_output );
 526                         out.write( domain_id );
 527                         out.write( separator_for_output );
 528                         out.write( "/" );
 529                         out.write( from + "-" + to );
 530                         out.write( "/" );
 531                         out.write( SurfacingConstants.NL );
 532                         ++counter;
 533                     }
 534                 }
 535                 else {
 536                     final List<Domain> domains = protein.getProteinDomains( domain_id );
 537                     if ( domains.size() > 0 ) {
 538                         out.write( protein.getSpecies().getSpeciesId() );
 539                         out.write( separator_for_output );
 540                         out.write( protein.getProteinId().getId() );
 541                         out.write( separator_for_output );
 542                         out.write( domain_id );
 543                         out.write( separator_for_output );
 544                         for( final Domain domain : domains ) {
 545                             if ( ( ie_cutoff < 0 ) || ( domain.getPerDomainEvalue() <= ie_cutoff ) ) {
 546                                 out.write( "/" );
 547                                 out.write( domain.getFrom() + "-" + domain.getTo() );
 548                             }
 549                         }
 550                         out.write( "/" );
 551                         out.write( separator_for_output );
 552                         final List<Domain> domain_list = new ArrayList<Domain>();
 553                         for( final Domain domain : protein.getProteinDomains() ) {
 554                             if ( ( ie_cutoff < 0 ) || ( domain.getPerDomainEvalue() <= ie_cutoff ) ) {
 555                                 domain_list.add( domain );
 556                             }
 557                         }
 558                         final Domain domain_ary[] = new Domain[ domain_list.size() ];
 559                         for( int i = 0; i < domain_list.size(); ++i ) {
 560                             domain_ary[ i ] = domain_list.get( i );
 561                         }
 562                         Arrays.sort( domain_ary, new DomainComparator( true ) );
 563                         out.write( "{" );
 564                         boolean first = true;
 565                         for( final Domain domain : domain_ary ) {
 566                             if ( first ) {
 567                                 first = false;
 568                             }
 569                             else {
 570                                 out.write( "," );
 571                             }
 572                             out.write( domain.getDomainId().toString() );
 573                             out.write( ":" + domain.getFrom() + "-" + domain.getTo() );
 574                             out.write( ":" + domain.getPerDomainEvalue() );
 575                         }
 576                         out.write( "}" );
 577                         if ( !( ForesterUtil.isEmpty( protein.getDescription() )
 578                                 || protein.getDescription().equals( SurfacingConstants.NONE ) ) ) {
 579                             out.write( protein.getDescription() );
 580                         }
 581                         out.write( separator_for_output );
 582                         if ( !( ForesterUtil.isEmpty( protein.getAccession() )
 583                                 || protein.getAccession().equals( SurfacingConstants.NONE ) ) ) {
 584                             out.write( protein.getAccession() );
 585                         }
 586                         out.write( SurfacingConstants.NL );
 587                         ++counter;
 588                     }
 589                 }
 590             }
 591         }
 592         out.flush();
 593         return counter;
 594     }
 595
 596     public static void main( final String[] args ) {
 597         Set<String> a = new HashSet<String>();
 598         Set<String> b = new HashSet<String>();
 599         Set<String> c = new HashSet<String>();
 600         Set<String> d = new HashSet<String>();
 601         a.add( "x" );
 602         a.add( "b" );
 603         a.add( "c" );
 604         b.add( "a" );
 605         b.add( "b" );
 606         b.add( "c" );
 607         c.add( "a" );
 608         c.add( "b" );
 609         c.add( "c" );
 610         c.add( "c" );
 611         c.add( "f" );
 612         d.add( "a" );
 613         d.add( "c" );
 614         d.add( "d" );
 615         List<Set<String>> domains_per_genome_list = new ArrayList<Set<String>>();
 616         domains_per_genome_list.add( a );
 617         domains_per_genome_list.add( b );
 618         domains_per_genome_list.add( c );
 619         domains_per_genome_list.add( d );
 620         Set<String> x = calcIntersection( domains_per_genome_list );
 621         System.out.println( x );
 622     }
 623 }