)" );
}
System.out.println( "Output directory : " + out_dir );
System.out.println( "Input genomes from : " + input_genomes_file );
html_desc.append( "| Input genomes from: | " + input_genomes_file + " |
" + nl );
if ( positive_filter_file != null ) {
final int filter_size = filter.size();
System.out.println( "Positive protein filter : " + positive_filter_file + " [" + filter_size
+ " domain ids]" );
html_desc.append( "| Positive protein filter: | " + positive_filter_file + " [" + filter_size
+ " domain ids] |
" + nl );
}
if ( negative_filter_file != null ) {
final int filter_size = filter.size();
System.out.println( "Negative protein filter : " + negative_filter_file + " [" + filter_size
+ " domain ids]" );
html_desc.append( "| Negative protein filter: | " + negative_filter_file + " [" + filter_size
+ " domain ids] |
" + nl );
}
if ( negative_domains_filter_file != null ) {
final int filter_size = filter.size();
System.out.println( "Negative domain filter : " + negative_domains_filter_file + " [" + filter_size
+ " domain ids]" );
html_desc.append( "| Negative domain filter: | " + negative_domains_filter_file + " ["
+ filter_size + " domain ids] |
" + nl );
}
if ( plus_minus_analysis_high_copy_base_species.size() > 0 ) {
String plus0 = "";
for( final String s : plus_minus_analysis_high_copy_base_species ) {
plus0 += "+" + s + " ";
}
String plus1 = "";
for( final String s : plus_minus_analysis_high_copy_target_species ) {
plus1 += "*" + s + " ";
}
String minus = "";
for( final String s : plus_minus_analysis_high_low_copy_species ) {
minus += "-" + s + " ";
}
System.out.println( "Plus-minus analysis : " + plus1 + "&& " + plus0 + "&& " + minus );
html_desc.append( "| Plus-minus analysis: | " + plus1 + "&& " + plus0 + "&& " + minus
+ " |
" + nl );
}
if ( cutoff_scores_file != null ) {
System.out.println( "Cutoff scores file : " + cutoff_scores_file );
html_desc.append( "| Cutoff scores file: | " + cutoff_scores_file + " |
" + nl );
}
if ( ie_value_max >= 0.0 ) {
System.out.println( "iE-value maximum (incl) : " + ie_value_max );
html_desc.append( "| iE-value maximum (inclusive): | " + ie_value_max + " |
" + nl );
}
if ( rel_env_length_ratio_cutoff > 0.0 ) {
System.out.println( "Rel env length ratio min : " + rel_env_length_ratio_cutoff );
html_desc.append( "| Relative hmm envelope length ratio min (inclusive): | "
+ rel_env_length_ratio_cutoff + " |
" + nl );
}
if ( fs_e_value_max >= 0.0 ) {
System.out.println( "FS E-value maximum (incl) : " + fs_e_value_max );
html_desc.append( "| FS E-value maximum (inclusive): | " + fs_e_value_max + " |
" + nl );
}
if ( output_protein_lists_for_all_domains ) {
System.out.println( "Domain E-value max : " + output_list_of_all_proteins_per_domain_e_value_max );
html_desc.append( "| Protein lists: E-value maximum per domain (inclusive): | "
+ output_list_of_all_proteins_per_domain_e_value_max + " |
" + nl );
}
System.out.println( "Ignore DUFs : " + ignore_dufs );
if ( ignore_virus_like_ids ) {
System.out.println( "Ignore virus like ids : " + ignore_virus_like_ids );
html_desc.append( "| Ignore virus, phage, transposition related ids: | " + ignore_virus_like_ids
+ " |
" + nl );
}
html_desc.append( "| Ignore DUFs: | " + ignore_dufs + " |
" + nl );
if ( max_allowed_overlap != surfacing.MAX_ALLOWED_OVERLAP_DEFAULT ) {
System.out.println( "Max allowed domain overlap : " + max_allowed_overlap );
html_desc
.append( "| Max allowed domain overlap: | " + max_allowed_overlap + " |
" + nl );
}
if ( no_engulfing_overlaps ) {
System.out.println( "Ignore engulfed domains : " + no_engulfing_overlaps );
html_desc.append( "| Ignore (lower confidence) engulfed domains: | " + no_engulfing_overlaps
+ " |
" + nl );
}
System.out.println( "Ignore singlet domains : " + ignore_domains_without_combs_in_all_spec );
html_desc
.append( "| Ignore singlet domains for domain combination similarity analyses (not for parsimony analyses): | "
+ ignore_domains_without_combs_in_all_spec + " |
" + nl );
System.out.println( "Ignore species specific doms: " + ignore_species_specific_domains );
html_desc
.append( "| Ignore species specific domains for domain combination similarity analyses (not for parsimony analyses): | "
+ ignore_species_specific_domains + " |
" + nl );
System.out.println( "Ignore combination with self: " + ignore_combination_with_same );
html_desc.append( "| Ignore combination with self for domain combination similarity analyses: | "
+ ignore_combination_with_same + " |
" + nl );
System.out.println( "Consider directedness : "
+ ( dc_type != BinaryDomainCombination.DomainCombinationType.BASIC ) );
html_desc.append( "| Consider directedness of binary domain combinations: | "
+ ( dc_type != BinaryDomainCombination.DomainCombinationType.BASIC ) + " |
" + nl );
if ( dc_type != BinaryDomainCombination.DomainCombinationType.BASIC ) {
System.out.println( "Consider adjacency : "
+ ( dc_type == BinaryDomainCombination.DomainCombinationType.DIRECTED_ADJACTANT ) );
html_desc.append( "| Consider djacency of binary domain combinations: | "
+ ( dc_type == BinaryDomainCombination.DomainCombinationType.DIRECTED_ADJACTANT ) + " |
"
+ nl );
}
System.out.println( "Fitch parsimony of DCs : " + perform_dc_fich );
html_desc.append( "| Fitch parsimony of DCs: | " + perform_dc_fich + " |
" + nl );
if ( perform_dc_fich ) {
System.out.println( "Use last in Fitch parsimony : " + use_last_in_fitch_parsimony );
html_desc.append( "| Use last in Fitch parsimony: | " + use_last_in_fitch_parsimony
+ " |
" + nl );
}
System.out.println( "Write to Nexus files : " + write_to_nexus );
html_desc.append( "| Write to Nexus files: | " + write_to_nexus + " |
" + nl );
if ( perform_dc_fich ) {
System.out.println( "DC regain prot stats : " + perform_dc_regain_proteins_stats );
html_desc.append( "| DC regain prot stats: | " + perform_dc_regain_proteins_stats + " |
"
+ nl );
}
System.out.println( "DA analysis : " + da_analysis );
html_desc.append( "| DA analysis : | " + da_analysis + " |
" + nl );
System.out.print( "Domain counts sort order : " );
html_desc.append( "| Domain counts sort order: | " );
switch ( dc_sort_order ) {
case ALPHABETICAL_KEY_ID:
System.out.println( "alphabetical" );
html_desc.append( "alphabetical" + " |
" + nl );
break;
case KEY_DOMAIN_COUNT:
System.out.println( "domain count" );
html_desc.append( "domain count" + "" + nl );
break;
case KEY_DOMAIN_PROTEINS_COUNT:
System.out.println( "domain proteins count" );
html_desc.append( "domain proteins count" + "" + nl );
break;
case COMBINATIONS_COUNT:
System.out.println( "domain combinations count" );
html_desc.append( "domain combinations count" + "" + nl );
break;
default:
ForesterUtil.unexpectedFatalError( surfacing.PRG_NAME, "unknown value for dc sort order" );
}
if ( domain_id_to_go_ids_map != null ) {
System.out.println( "Pfam to GO mappings from : " + pfam_to_go_file + " [" + domain_id_to_go_ids_count
+ " mappings]" );
html_desc.append( "| Pfam to GO mappings from: | " + pfam_to_go_file + " ["
+ domain_id_to_go_ids_count + " mappings]" + " |
" + nl );
}
if ( go_terms != null ) {
System.out.println( "GO terms from : " + go_obo_file + " [" + go_terms.size() + " terms]" );
html_desc.append( "| GO terms from: | " + go_obo_file + " [" + go_terms.size() + " terms]"
+ " |
" + nl );
}
if ( go_namespace_limit != null ) {
System.out.println( "Limit GO terms to : " + go_namespace_limit.toString() );
html_desc.append( "| Limit GO terms to | " + go_namespace_limit + " |
" + nl );
}
if ( perform_pwc ) {
System.out.println( "Suffix for PWC files : " + automated_pairwise_comparison_suffix );
html_desc.append( "| Suffix for PWC files | " + automated_pairwise_comparison_suffix
+ " |
" + nl );
}
if ( out_dir != null ) {
System.out.println( "Output directory : " + out_dir );
}
if ( query_domain_ids != null ) {
System.out.println( "Query domains (ordered) : " + query_domain_ids );
html_desc.append( " | " + query_domain_ids + " |
" + nl );
}
System.out.println( "Write similarities to : " + output_file );
System.out.print( " Scoring method : " );
html_desc.append( "| Scoring method: | " );
switch ( scoring ) {
case COMBINATIONS:
System.out.println( "domain combinations based" );
html_desc.append( "domain combinations based" + " |
" + nl );
break;
case DOMAINS:
System.out.println( "domain counts based" );
html_desc.append( "domain counts based" + "" + nl );
break;
case PROTEINS:
System.out.println( "domain proteins counts based" );
html_desc.append( "domain proteins counts based" + "" + nl );
break;
default:
ForesterUtil.unexpectedFatalError( surfacing.PRG_NAME, "unknown value for sorting for scoring" );
}
System.out.print( " Sort by : " );
html_desc.append( "| Sort by: | " );
switch ( domain_similarity_sort_field ) {
case MIN:
System.out.print( "score minimum" );
html_desc.append( "score minimum" );
break;
case MAX:
System.out.print( "score maximum" );
html_desc.append( "score maximum" );
break;
case MEAN:
System.out.print( "score mean" );
html_desc.append( "score mean" );
break;
case SD:
System.out.print( "score standard deviation" );
html_desc.append( "score standard deviation" );
break;
case SPECIES_COUNT:
System.out.print( "species number" );
html_desc.append( "species number" );
break;
case DOMAIN_ID:
System.out.print( "alphabetical domain identifier" );
html_desc.append( "alphabetical domain identifier" );
break;
case MAX_DIFFERENCE:
System.out.print( "(maximal) difference" );
html_desc.append( "(maximal) difference" );
break;
case ABS_MAX_COUNTS_DIFFERENCE:
System.out.print( "absolute (maximal) counts difference" );
html_desc.append( "absolute (maximal) counts difference" );
break;
case MAX_COUNTS_DIFFERENCE:
System.out.print( "(maximal) counts difference" );
html_desc.append( "(maximal) counts difference" );
break;
default:
ForesterUtil.unexpectedFatalError( surfacing.PRG_NAME, "unknown value for sorting for similarities" );
}
if ( sort_by_species_count_first ) {
System.out.println( " (sort by species count first)" );
html_desc.append( " (sort by species count first)" );
}
else {
System.out.println();
}
html_desc.append( " |
" + nl );
System.out.print( " Detailedness : " );
switch ( detailedness ) {
case BASIC:
System.out.println( "basic" );
break;
case LIST_COMBINING_DOMAIN_FOR_EACH_SPECIES:
System.out.println( "list combining domains for each species" );
break;
case PUNCTILIOUS:
System.out.println( "punctilious" );
break;
default:
ForesterUtil.unexpectedFatalError( surfacing.PRG_NAME, "unknown value for sorting for detailedness" );
}
System.out.print( " Print option : " );
switch ( domain_similarity_print_option ) {
case HTML:
System.out.println( "HTML" );
break;
case SIMPLE_TAB_DELIMITED:
System.out.println( "simple tab delimited" );
break;
default:
ForesterUtil.unexpectedFatalError( surfacing.PRG_NAME, "unknown value for print option" );
}
System.out.print( " Species matrix : " + species_matrix );
System.out.println();
final File dc_data_file = new File( out_dir + ForesterUtil.FILE_SEPARATOR + output_file + DATA_FILE_SUFFIX );
System.out.println( "Domain comb data output : " + dc_data_file );
html_desc.append( "| Domain combination data output: | " + dc_data_file + " |
" );
System.out.println();
if ( perform_pwc ) {
System.out.println( "Pairwise comparisons: " );
html_desc.append( "| Pairwise comparisons: | |
" );
System.out.print( " Sort by : " );
html_desc.append( "| Sort by: | " );
switch ( domain_similarity_sort_field_for_automated_pwc ) {
case MEAN:
System.out.print( "score mean" );
html_desc.append( "score mean" );
break;
case DOMAIN_ID:
System.out.print( "alphabetical domain identifier" );
html_desc.append( "alphabetical domain identifier" );
break;
case MAX_DIFFERENCE:
System.out.print( "difference" );
html_desc.append( "difference" );
break;
case ABS_MAX_COUNTS_DIFFERENCE:
System.out.print( "absolute counts difference" );
html_desc.append( "absolute counts difference" );
break;
case MAX_COUNTS_DIFFERENCE:
System.out.print( "counts difference" );
html_desc.append( "counts difference" );
break;
default:
ForesterUtil.unexpectedFatalError( surfacing.PRG_NAME,
"unknown value for sorting for similarities" );
}
System.out.println();
html_desc.append( " |
" + nl );
if ( ( intrees != null ) && ( intrees.length > 0 ) ) {
for( final File intree_file : intree_files ) {
html_desc.append( "| Intree for gain/loss parsimony analysis: | " + intree_file
+ " |
" + nl );
System.out.println( " Intree for gain/loss pars.: " + intree_file );
}
}
if ( radomize_fitch_parsimony ) {
html_desc.append( "| Random number seed for Fitch parsimony analysis: | "
+ random_number_seed_for_fitch_parsimony + " |
" + nl );
System.out.println( " Random number seed : " + random_number_seed_for_fitch_parsimony );
}
if ( ( domain_id_to_secondary_features_maps != null )
&& ( domain_id_to_secondary_features_maps.length > 0 ) ) {
for( int i = 0; i < secondary_features_map_files.length; i++ ) {
html_desc.append( "| Secondary features map file: | "
+ secondary_features_map_files[ i ] + " |
" + nl );
System.out.println( "Secondary features map file : " + secondary_features_map_files[ i ]
+ " [mappings for " + domain_id_to_secondary_features_maps[ i ].size() + " domain ids]" );
if ( VERBOSE ) {
System.out.println();
System.out.println( "Domain ids to secondary features map:" );
for( final String domain_id : domain_id_to_secondary_features_maps[ i ].keySet() ) {
System.out.print( domain_id );
System.out.print( " => " );
for( final String sec : domain_id_to_secondary_features_maps[ i ].get( domain_id ) ) {
System.out.print( sec );
System.out.print( " " );
}
System.out.println();
}
}
}
}
} // if ( perform_pwc ) {
System.out.println();
html_desc.append( "| Command line: | " + nl + nl + cla.getCommandLineArgsAsString() + nl + nl
+ " |
" + nl );
System.out.println( "Command line : " + cla.getCommandLineArgsAsString() );
BufferedWriter[] query_domains_writer_ary = null;
List[] query_domain_ids_array = null;
if ( query_domain_ids != null ) {
final String[] query_domain_ids_str_array = query_domain_ids.split( "#" );
query_domain_ids_array = new ArrayList[ query_domain_ids_str_array.length ];
query_domains_writer_ary = new BufferedWriter[ query_domain_ids_str_array.length ];
for( int i = 0; i < query_domain_ids_str_array.length; i++ ) {
String query_domain_ids_str = query_domain_ids_str_array[ i ];
final String[] query_domain_ids_str_ary = query_domain_ids_str.split( "~" );
final List query = new ArrayList();
for( final String element : query_domain_ids_str_ary ) {
query.add( element );
}
query_domain_ids_array[ i ] = query;
query_domain_ids_str = query_domain_ids_str.replace( '~', '_' );
String protein_names_writer_str = query_domain_ids_str + surfacing.SEQ_EXTRACT_SUFFIX;
if ( out_dir != null ) {
protein_names_writer_str = out_dir + ForesterUtil.FILE_SEPARATOR + protein_names_writer_str;
}
try {
query_domains_writer_ary[ i ] = new BufferedWriter( new FileWriter( protein_names_writer_str ) );
}
catch ( final IOException e ) {
ForesterUtil.fatalError( surfacing.PRG_NAME,
"Could not open [" + protein_names_writer_str + "]: "
+ e.getLocalizedMessage() );
}
}
}
SortedMap> protein_lists_per_species = null; //This will only be created if needed.
boolean need_protein_lists_per_species = false;
if ( ( plus_minus_analysis_high_copy_base_species.size() > 0 ) || output_protein_lists_for_all_domains
|| true ) { //TODO
need_protein_lists_per_species = true;
}
if ( need_protein_lists_per_species ) {
protein_lists_per_species = new TreeMap>();
}
List gwcd_list = new ArrayList( number_of_genomes );
final SortedSet all_domains_encountered = new TreeSet();
final SortedSet all_bin_domain_combinations_encountered = new TreeSet();
List all_bin_domain_combinations_gained_fitch = null;
List all_bin_domain_combinations_lost_fitch = null;
if ( ( intrees != null ) && ( intrees.length == 1 ) ) {
all_bin_domain_combinations_gained_fitch = new ArrayList();
all_bin_domain_combinations_lost_fitch = new ArrayList();
}
final File per_genome_domain_promiscuity_statistics_file = new File( out_dir + ForesterUtil.FILE_SEPARATOR
+ output_file + D_PROMISCUITY_FILE_SUFFIX );
BufferedWriter per_genome_domain_promiscuity_statistics_writer = null;
try {
per_genome_domain_promiscuity_statistics_writer = new BufferedWriter( new FileWriter( per_genome_domain_promiscuity_statistics_file ) );
per_genome_domain_promiscuity_statistics_writer.write( "Species:\t" );
per_genome_domain_promiscuity_statistics_writer.write( "Mean:\t" );
per_genome_domain_promiscuity_statistics_writer.write( "SD:\t" );
per_genome_domain_promiscuity_statistics_writer.write( "Median:\t" );
per_genome_domain_promiscuity_statistics_writer.write( "Min:\t" );
per_genome_domain_promiscuity_statistics_writer.write( "Max:\t" );
per_genome_domain_promiscuity_statistics_writer.write( "N:\t" );
per_genome_domain_promiscuity_statistics_writer
.write( "Max Promiscuous Domains:" + ForesterUtil.LINE_SEPARATOR );
}
catch ( final IOException e2 ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e2.getMessage() );
}
final File log_file = new File( out_dir + ForesterUtil.FILE_SEPARATOR + output_file + LOG_FILE_SUFFIX );
BufferedWriter log_writer = null;
try {
log_writer = new BufferedWriter( new FileWriter( log_file ) );
}
catch ( final IOException e2 ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e2.getMessage() );
}
BufferedWriter dc_data_writer = null;
try {
dc_data_writer = new BufferedWriter( new FileWriter( dc_data_file ) );
dc_data_writer.write( DATA_FILE_DESC );
dc_data_writer.write( ForesterUtil.LINE_SEPARATOR );
}
catch ( final IOException e2 ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e2.getMessage() );
}
DescriptiveStatistics protein_coverage_stats = new BasicDescriptiveStatistics();
DescriptiveStatistics all_genomes_domains_per_potein_stats = new BasicDescriptiveStatistics();
final SortedMap all_genomes_domains_per_potein_histo = new TreeMap();
final SortedSet domains_which_are_always_single = new TreeSet();
final SortedSet domains_which_are_sometimes_single_sometimes_not = new TreeSet();
final SortedSet domains_which_never_single = new TreeSet();
BufferedWriter domains_per_potein_stats_writer = null;
try {
domains_per_potein_stats_writer = new BufferedWriter( new FileWriter( out_dir + ForesterUtil.FILE_SEPARATOR
+ output_file + "_domains_per_potein_stats.txt" ) );
domains_per_potein_stats_writer.write( "Genome" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( "Mean" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( "SD" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( "Median" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( "N" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( "Min" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( "Max" );
domains_per_potein_stats_writer.write( "\n" );
}
catch ( final IOException e3 ) {
e3.printStackTrace();
}
Map protein_length_stats_by_dc = null;
Map domain_number_stats_by_dc = null;
final Map domain_length_stats_by_domain = new HashMap();
if ( perform_dc_regain_proteins_stats ) {
protein_length_stats_by_dc = new HashMap();
domain_number_stats_by_dc = new HashMap();
}
DomainLengthsTable domain_lengths_table = null;
if ( domain_length_analysis ) {
domain_lengths_table = new DomainLengthsTable();
}
// Main loop:
final SortedMap> distinct_domain_architecutures_per_genome = new TreeMap>();
final SortedMap distinct_domain_architecuture_counts = new TreeMap();
for( int i = 0; i < number_of_genomes; ++i ) {
System.out.println();
System.out.println( ( i + 1 ) + "/" + number_of_genomes );
SurfacingUtil.log( ( i + 1 ) + "/" + number_of_genomes, log_writer );
System.out.println( "Processing : " + input_file_properties[ i ][ 1 ]
+ " [" + input_file_properties[ i ][ 0 ] + "]" );
SurfacingUtil.log( "Genome : " + input_file_properties[ i ][ 1 ]
+ " [" + input_file_properties[ i ][ 0 ] + "]", log_writer );
HmmscanPerDomainTableParser parser = null;
INDIVIDUAL_SCORE_CUTOFF ind_score_cutoff = INDIVIDUAL_SCORE_CUTOFF.NONE;
if ( individual_score_cutoffs != null ) {
ind_score_cutoff = INDIVIDUAL_SCORE_CUTOFF_DEFAULT;
}
if ( ( positive_filter_file != null ) || ( negative_filter_file != null )
|| ( negative_domains_filter_file != null ) ) {
HmmscanPerDomainTableParser.FilterType filter_type = HmmscanPerDomainTableParser.FilterType.NONE;
if ( positive_filter_file != null ) {
filter_type = HmmscanPerDomainTableParser.FilterType.POSITIVE_PROTEIN;
}
else if ( negative_filter_file != null ) {
filter_type = HmmscanPerDomainTableParser.FilterType.NEGATIVE_PROTEIN;
}
else if ( negative_domains_filter_file != null ) {
filter_type = HmmscanPerDomainTableParser.FilterType.NEGATIVE_DOMAIN;
}
parser = new HmmscanPerDomainTableParser( new File( input_file_properties[ i ][ 0 ] ),
input_file_properties[ i ][ 1 ],
filter,
filter_type,
ind_score_cutoff,
true );
}
else {
parser = new HmmscanPerDomainTableParser( new File( input_file_properties[ i ][ 0 ] ),
input_file_properties[ i ][ 1 ],
ind_score_cutoff,
true );
}
if ( fs_e_value_max >= 0.0 ) {
parser.setFsEValueMaximum( fs_e_value_max );
}
if ( ie_value_max >= 0.0 ) {
parser.setIEValueMaximum( ie_value_max );
}
if ( rel_env_length_ratio_cutoff > 0.0 ) {
parser.setRelEnvLengthRatioCutoff( rel_env_length_ratio_cutoff );
}
parser.setIgnoreDufs( ignore_dufs );
parser.setIgnoreVirusLikeIds( ignore_virus_like_ids );
parser.setIgnoreEngulfedDomains( no_engulfing_overlaps );
if ( max_allowed_overlap != surfacing.MAX_ALLOWED_OVERLAP_DEFAULT ) {
parser.setMaxAllowedOverlap( max_allowed_overlap );
}
parser.setReturnType( HmmscanPerDomainTableParser.ReturnType.UNORDERED_PROTEIN_DOMAIN_COLLECTION_PER_PROTEIN );
if ( individual_score_cutoffs != null ) {
parser.setIndividualScoreCutoffs( individual_score_cutoffs );
}
List protein_list = null;
try {
protein_list = parser.parse();
}
catch ( final IOException e ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e.getMessage() );
}
catch ( final Exception e ) {
ForesterUtil.unexpectedFatalError( surfacing.PRG_NAME, e.getMessage(), e );
}
if ( VERBOSE ) {
System.out.println( "Domains ignored due to negative domain filter: " );
ForesterUtil.printCountingMap( parser.getDomainsIgnoredDueToNegativeDomainFilterCountsMap() );
System.out.println( "Domains ignored due to virus like id: " );
ForesterUtil.printCountingMap( parser.getDomainsIgnoredDueToVirusLikeIdCountsMap() );
}
final double coverage = ( double ) protein_list.size() / parser.getProteinsEncountered();
protein_coverage_stats.addValue( coverage );
int distinct_das = -1;
if ( da_analysis ) {
final String genome = input_file_properties[ i ][ 0 ];
distinct_das = SurfacingUtil.storeDomainArchitectures( genome,
distinct_domain_architecutures_per_genome,
protein_list,
distinct_domain_architecuture_counts );
}
System.out.println( "Number of proteins encountered : " + parser.getProteinsEncountered() );
SurfacingUtil.log( "Number of proteins encountered : " + parser.getProteinsEncountered(),
log_writer );
System.out.println( "Number of proteins stored : " + protein_list.size() );
SurfacingUtil.log( "Number of proteins stored : " + protein_list.size(), log_writer );
System.out.println( "Coverage : "
+ ForesterUtil.roundToInt( 100.0 * coverage ) + "%" );
SurfacingUtil.log( "Coverage : "
+ ForesterUtil.roundToInt( 100.0 * coverage ) + "%", log_writer );
System.out.println( "Domains encountered : " + parser.getDomainsEncountered() );
SurfacingUtil.log( "Domains encountered : " + parser.getDomainsEncountered(),
log_writer );
System.out.println( "Domains stored : " + parser.getDomainsStored() );
SurfacingUtil.log( "Domains stored : " + parser.getDomainsStored(),
log_writer );
System.out.println( "Distinct domains stored : "
+ parser.getDomainsStoredSet().size() );
SurfacingUtil
.log( "Distinct domains stored : " + parser.getDomainsStoredSet().size(),
log_writer );
System.out.println( "Domains ignored due to individual score cutoffs: "
+ parser.getDomainsIgnoredDueToIndividualScoreCutoff() );
SurfacingUtil.log( "Domains ignored due to individual score cutoffs: "
+ parser.getDomainsIgnoredDueToIndividualScoreCutoff(), log_writer );
System.out.println( "Domains ignored due to FS E-value : "
+ parser.getDomainsIgnoredDueToFsEval() );
SurfacingUtil
.log( "Domains ignored due to FS E-value : " + parser.getDomainsIgnoredDueToFsEval(),
log_writer );
System.out.println( "Domains ignored due to iE-value : "
+ parser.getDomainsIgnoredDueToIEval() );
SurfacingUtil
.log( "Domains ignored due to iE-value : " + parser.getDomainsIgnoredDueToIEval(),
log_writer );
System.out.println( "Domains ignored due to rel env length ratio : "
+ parser.getDomainsIgnoredDueToRelEnvLengthRatioCutoff() );
SurfacingUtil.log( "Domains ignored due to rel env length ratio : "
+ parser.getDomainsIgnoredDueToRelEnvLengthRatioCutoff(), log_writer );
System.out.println( "Domains ignored due to DUF designation : "
+ parser.getDomainsIgnoredDueToDuf() );
SurfacingUtil.log( "Domains ignored due to DUF designation : " + parser.getDomainsIgnoredDueToDuf(),
log_writer );
if ( ignore_virus_like_ids ) {
System.out.println( "Domains ignored due virus like ids : "
+ parser.getDomainsIgnoredDueToVirusLikeIds() );
SurfacingUtil.log( "Domains ignored due virus like ids : "
+ parser.getDomainsIgnoredDueToVirusLikeIds(), log_writer );
}
System.out.println( "Domains ignored due negative domain filter : "
+ parser.getDomainsIgnoredDueToNegativeDomainFilter() );
SurfacingUtil.log( "Domains ignored due negative domain filter : "
+ parser.getDomainsIgnoredDueToNegativeDomainFilter(), log_writer );
System.out.println( "Domains ignored due to overlap : "
+ parser.getDomainsIgnoredDueToOverlap() );
SurfacingUtil
.log( "Domains ignored due to overlap : " + parser.getDomainsIgnoredDueToOverlap(),
log_writer );
if ( negative_filter_file != null ) {
System.out.println( "Proteins ignored due to negative filter : "
+ parser.getProteinsIgnoredDueToFilter() );
SurfacingUtil.log( "Proteins ignored due to negative filter : "
+ parser.getProteinsIgnoredDueToFilter(), log_writer );
}
if ( positive_filter_file != null ) {
System.out.println( "Proteins ignored due to positive filter : "
+ parser.getProteinsIgnoredDueToFilter() );
SurfacingUtil.log( "Proteins ignored due to positive filter : "
+ parser.getProteinsIgnoredDueToFilter(), log_writer );
}
if ( da_analysis ) {
System.out.println( "Distinct domain architectures stored : " + distinct_das );
SurfacingUtil.log( "Distinct domain architectures stored : " + distinct_das, log_writer );
}
System.out.println( "Time for processing : " + parser.getTime() + "ms" );
SurfacingUtil.log( "", log_writer );
try {
int count = 0;
for( final Protein protein : protein_list ) {
dc_data_writer
.write( SurfacingUtil.proteinToDomainCombinations( protein, count + "", "\t" ).toString() );
++count;
for( final Domain d : protein.getProteinDomains() ) {
final String d_str = d.getDomainId().toString();
if ( !domain_length_stats_by_domain.containsKey( d_str ) ) {
domain_length_stats_by_domain.put( d_str, new BasicDescriptiveStatistics() );
}
domain_length_stats_by_domain.get( d_str ).addValue( d.getLength() );
}
}
}
catch ( final IOException e ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e.toString() );
}
SurfacingUtil.domainsPerProteinsStatistics( input_file_properties[ i ][ 1 ],
protein_list,
all_genomes_domains_per_potein_stats,
all_genomes_domains_per_potein_histo,
domains_which_are_always_single,
domains_which_are_sometimes_single_sometimes_not,
domains_which_never_single,
domains_per_potein_stats_writer );
if ( domain_length_analysis ) {
domain_lengths_table.addLengths( protein_list );
}
if ( !da_analysis ) {
gwcd_list.add( BasicGenomeWideCombinableDomains.createInstance( protein_list,
ignore_combination_with_same,
new BasicSpecies( input_file_properties[ i ][ 1 ] ),
domain_id_to_go_ids_map,
dc_type,
protein_length_stats_by_dc,
domain_number_stats_by_dc ) );
if ( gwcd_list.get( i ).getSize() > 0 ) {
if ( output_binary_domain_combinationsfor_counts ) {
SurfacingUtil.writeDomainCombinationsCountsFile( input_file_properties,
out_dir,
per_genome_domain_promiscuity_statistics_writer,
gwcd_list.get( i ),
i,
dc_sort_order );
}
if ( output_binary_domain_combinationsfor_graph_analysis ) {
SurfacingUtil.writeBinaryDomainCombinationsFileForGraphAnalysis( input_file_properties,
out_dir,
gwcd_list.get( i ),
i,
dc_sort_order );
}
SurfacingUtil.addAllDomainIdsToSet( gwcd_list.get( i ), all_domains_encountered );
SurfacingUtil.addAllBinaryDomainCombinationToSet( gwcd_list.get( i ),
all_bin_domain_combinations_encountered );
}
}
if ( query_domains_writer_ary != null ) {
for( int j = 0; j < query_domain_ids_array.length; j++ ) {
try {
SurfacingUtil.extractProteinNames( protein_list,
query_domain_ids_array[ j ],
query_domains_writer_ary[ j ],
"\t",
LIMIT_SPEC_FOR_PROT_EX );
query_domains_writer_ary[ j ].flush();
}
catch ( final IOException e ) {
e.printStackTrace();
}
}
}
if ( need_protein_lists_per_species ) {
protein_lists_per_species.put( new BasicSpecies( input_file_properties[ i ][ 1 ] ), protein_list );
}
try {
log_writer.flush();
}
catch ( final IOException e2 ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e2.getLocalizedMessage() );
}
System.gc();
} // for( int i = 0; i < number_of_genomes; ++i ) {
ForesterUtil
.programMessage( PRG_NAME,
"Wrote domain promiscuities to: " + per_genome_domain_promiscuity_statistics_file );
final int LEVEL = 0;
try {
MinimalDomainomeCalculator.calc( false,
intrees[ 0 ],
LEVEL,
protein_lists_per_species,
SEPARATOR_FOR_DA,
-1,
out_dir.toString() + "/" + output_file,
true );
}
catch ( IOException e ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e.getLocalizedMessage() );
}
try {
MinimalDomainomeCalculator.calc( true,
intrees[ 0 ],
LEVEL,
protein_lists_per_species,
SEPARATOR_FOR_DA,
-1,
out_dir.toString() + "/" + output_file,
true );
}
catch ( IOException e ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e.getLocalizedMessage() );
}
if ( da_analysis ) {
SurfacingUtil.performDomainArchitectureAnalysis( distinct_domain_architecutures_per_genome,
distinct_domain_architecuture_counts,
10,
new File( out_dir.toString() + "/" + output_file
+ "_DA_counts.txt" ),
new File( out_dir.toString() + "/" + output_file
+ "_unique_DAs.txt" ) );
distinct_domain_architecutures_per_genome.clear();
distinct_domain_architecuture_counts.clear();
System.gc();
}
try {
domains_per_potein_stats_writer.write( "ALL" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( all_genomes_domains_per_potein_stats.arithmeticMean() + "" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer
.write( all_genomes_domains_per_potein_stats.sampleStandardDeviation() + "" );
domains_per_potein_stats_writer.write( "\t" );
if ( all_genomes_domains_per_potein_stats.getN() <= 300 ) {
domains_per_potein_stats_writer.write( all_genomes_domains_per_potein_stats.median() + "" );
domains_per_potein_stats_writer.write( "\t" );
}
domains_per_potein_stats_writer.write( all_genomes_domains_per_potein_stats.getN() + "" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( all_genomes_domains_per_potein_stats.getMin() + "" );
domains_per_potein_stats_writer.write( "\t" );
domains_per_potein_stats_writer.write( all_genomes_domains_per_potein_stats.getMax() + "" );
domains_per_potein_stats_writer.write( "\n" );
domains_per_potein_stats_writer.close();
all_genomes_domains_per_potein_stats = null;
SurfacingUtil.printOutPercentageOfMultidomainProteins( all_genomes_domains_per_potein_histo, log_writer );
ForesterUtil.map2file(
new File( out_dir + ForesterUtil.FILE_SEPARATOR + output_file
+ "_all_genomes_domains_per_potein_histo.txt" ),
all_genomes_domains_per_potein_histo,
"\t",
"\n" );
ForesterUtil.collection2file(
new File( out_dir + ForesterUtil.FILE_SEPARATOR + output_file
+ "_domains_always_single_.txt" ),
domains_which_are_always_single,
"\n" );
ForesterUtil.collection2file(
new File( out_dir + ForesterUtil.FILE_SEPARATOR + output_file
+ "_domains_single_or_combined.txt" ),
domains_which_are_sometimes_single_sometimes_not,
"\n" );
ForesterUtil.collection2file(
new File( out_dir + ForesterUtil.FILE_SEPARATOR + output_file
+ "_domains_always_combined.txt" ),
domains_which_never_single,
"\n" );
ForesterUtil.programMessage( PRG_NAME,
"Average of proteins with a least one domain assigned: "
+ ( 100 * protein_coverage_stats.arithmeticMean() ) + "% (+/-"
+ ( 100 * protein_coverage_stats.sampleStandardDeviation() ) + "%)" );
ForesterUtil.programMessage( PRG_NAME,
"Range of proteins with a least one domain assigned: "
+ ( 100 * protein_coverage_stats.getMin() ) + "%-"
+ ( 100 * protein_coverage_stats.getMax() ) + "%" );
SurfacingUtil.log(
"Average of prot with a least one dom assigned : "
+ ( 100 * protein_coverage_stats.arithmeticMean() ) + "% (+/-"
+ ( 100 * protein_coverage_stats.sampleStandardDeviation() ) + "%)",
log_writer );
SurfacingUtil.log( "Range of prot with a least one dom assigned : "
+ ( 100 * protein_coverage_stats.getMin() ) + "%-" + ( 100 * protein_coverage_stats.getMax() )
+ "%", log_writer );
protein_coverage_stats = null;
}
catch ( final IOException e2 ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e2.getLocalizedMessage() );
}
if ( query_domains_writer_ary != null ) {
for( int j = 0; j < query_domain_ids_array.length; j++ ) {
try {
query_domains_writer_ary[ j ].close();
}
catch ( final IOException e ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e.toString() );
}
}
}
try {
per_genome_domain_promiscuity_statistics_writer.close();
dc_data_writer.close();
log_writer.close();
}
catch ( final IOException e2 ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e2.getLocalizedMessage() );
}
if ( domain_length_analysis ) {
try {
SurfacingUtil.executeDomainLengthAnalysis( input_file_properties,
number_of_genomes,
domain_lengths_table,
domain_lengths_analysis_outfile );
}
catch ( final IOException e1 ) {
ForesterUtil.fatalError( surfacing.PRG_NAME, e1.toString() );
}
System.out.println();
ForesterUtil.programMessage( PRG_NAME, "Wrote domain length data to: " + domain_lengths_analysis_outfile );
System.out.println();
}
domain_lengths_table = null;
final long analysis_start_time = new Date().getTime();
PairwiseDomainSimilarityCalculator pw_calc = null;
final DomainSimilarityCalculator calc = new BasicDomainSimilarityCalculator( domain_similarity_sort_field,
sort_by_species_count_first,
number_of_genomes == 2,
CALC_SIMILARITY_SCORES,
true );
switch ( scoring ) {
case COMBINATIONS:
pw_calc = new CombinationsBasedPairwiseDomainSimilarityCalculator();
break;
case DOMAINS:
pw_calc = new DomainCountsBasedPairwiseSimilarityCalculator();
break;
case PROTEINS:
pw_calc = new ProteinCountsBasedPairwiseDomainSimilarityCalculator();
break;
default:
ForesterUtil.unexpectedFatalError( surfacing.PRG_NAME, "unknown value for sorting for scoring" );
}
DomainSimilarityCalculator.GoAnnotationOutput go_annotation_output = DomainSimilarityCalculator.GoAnnotationOutput.NONE;
if ( domain_id_to_go_ids_map != null ) {
go_annotation_output = DomainSimilarityCalculator.GoAnnotationOutput.ALL;
}
final SortedSet similarities = calc.calculateSimilarities( pw_calc,
gwcd_list,
ignore_domains_without_combs_in_all_spec,
ignore_species_specific_domains );
SurfacingUtil.decoratePrintableDomainSimilarities( similarities, detailedness );
final Map tax_code_to_id_map = SurfacingUtil.createTaxCodeToIdMap( intrees[ 0 ] );
try {
String my_outfile = output_file.toString();
Map split_writers = null;
Writer writer = null;
if ( similarities.size() > MINIMAL_NUMBER_OF_SIMILARITIES_FOR_SPLITTING ) {
if ( my_outfile.endsWith( ".html" ) ) {
my_outfile = my_outfile.substring( 0, my_outfile.length() - 5 );
}
split_writers = new HashMap();
SurfacingUtil.createSplitWriters( out_dir, my_outfile, split_writers );
}
else if ( !my_outfile.endsWith( ".html" ) ) {
my_outfile += ".html";
writer = new BufferedWriter( new FileWriter( out_dir + ForesterUtil.FILE_SEPARATOR + my_outfile ) );
}
List species_order = null;
if ( species_matrix ) {
species_order = new ArrayList();
for( int i = 0; i < number_of_genomes; i++ ) {
species_order.add( new BasicSpecies( input_file_properties[ i ][ 1 ] ) );
}
}
html_desc.append( "| Sum of all distinct binary combinations: | "
+ all_bin_domain_combinations_encountered.size() + " |
" + nl );
html_desc.append( "| Sum of all distinct domains: | " + all_domains_encountered.size()
+ " |
" + nl );
html_desc.append( "| Analysis date/time: | "
+ new java.text.SimpleDateFormat( "yyyy.MM.dd HH:mm:ss" ).format( new java.util.Date() )
+ " |
" + nl );
html_desc.append( "