/* BaitFisher (version 1.2.8) a program for designing DNA target enrichment baits * BaitFilter (version 1.0.6) a program for selecting optimal bait regions * Copyright 2013-2017 by Christoph Mayer * * This source file is part of the BaitFisher-package. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with BaitFisher. If not, see . * * * For any enquiries send an Email to Christoph Mayer * c.mayer.zfmk@uni-bonn.de * * When publishing work that is based on the results please cite: * Mayer et al. 2016: BaitFisher: A software package for multi-species target DNA enrichment probe design * */ #ifndef CSEQUENCE_MOL_H #define CSEQUENCE_MOL_H // Changes: // 22.08.2009: According to the fasta format specifications, the sequence name is only the string between the ">" and // the first space. The rest of the line contains a sequence description or annotation information. // This is now reflected in the CSequence_Mol class. The variables full_name, name, and description // contain this information. // The sequence name variables are now of type faststring (not string as before). // 07.01.2011: Migrated to fastring2.h and CFile2_1.h // 30.04.2011: Sliding window CG-AT analysis // TODO: Data type handling is/was not optimal. // In function set_taxon_and_sequence the auto_detect_type always superset the // value the user specified when creating the CSequence_Mol object. // This caused unwanted changes of the data type. #include #include #include "faststring2.h" //#include "CFile/CFile3b.h" #include "CFile/CFile2_1.h" #include #include "basic-DNA-RNA-AA-routines.h" #include "fast-realloc-vector.h" #include #include class CSequence_Mol { public: enum DataTypesEnum { standard = 1, // characters with arbitrarily-assigned, // discrete states, such as discrete // morphological data dna, /* DNA sequences (states A, C, G, T) */ rna, /* RNA sequences (states A, C, G, U) */ // nucleotide, /* nucleotide sequences */ protein, /* amino acid sequences */ molecular, /* AA, dna, or rna */ unknown, auto_detect_type, mixed }; enum processing_flag { convert_toupper = 1, convert_ambig2N = 2, autodetecttype = 4, removegaps = 8, removestars = 16, compute_numbers_of_residues_flag = 32, gaps_to_ambig = 64 }; private: faststring full_name; // with description after first space faststring short_name; // without description after first space faststring description; // description only faststring data; DataTypesEnum type; char general_ambig; bool numbers_of_residues_computed; // General rule: If we convert symbols, we count the new symbols we have in memory, // not the symbols in the file. This is more consistent. // unsigned number_of_AAs; // Does not include Xs and ? unsigned number_of_DNARNA_bases; // Includes Us but not ambigs unsigned number_of_DNARNA_amgibs; // Includes Ns and '?' unsigned number_of_Us; unsigned number_of_gaps; unsigned number_of_stars; unsigned number_of_questionmarks; unsigned number_of_Xs; unsigned number_of_Ns; unsigned number_raw_original_length; //no spaces, but gaps and stars unsigned number_CG; // CG content in case of DNA/RNA fastvector gap_and_star_koords; fastvector gap_koords; fastvector star_koords; bool bitcode_recoded; private: void find_shortname_and_description() { full_name.removeSpacesBack(); full_name.removeSpacesFront(); faststring::size_t pos_description = full_name.find(' '); faststring::size_t full_name_len = full_name.size(); if (pos_description == faststring::npos) // no space -> no sequence description { pos_description = full_name.size(); short_name.assign(full_name.begin(), full_name.begin() + pos_description); } else { short_name.assign(full_name.begin(), full_name.begin() + pos_description); // Skip all spaces while (pos_description < full_name_len && full_name.get_unckecked(pos_description) == ' ') { // std::cerr << "-------------DEBUG: ++pos_description" << std::endl; ++pos_description; } // std::cerr << "-------------DEBUG: " << full_name.end() - (full_name.begin() + pos_description) << std::endl; // if (full_name.end() - (full_name.begin() + pos_description) > 0) // Should not occur any more!!!! // { description.assign(full_name.begin() + pos_description, full_name.end() ); // } } } void toupper_this_sequence() { data.toupper(); } // TODO: Keep case of ambig. void change_ambigs() { if (type == dna || type == rna) { char * it = data.begin(); char * it_end = data.end(); number_of_questionmarks = 0; number_of_Ns = 0; while (it != it_end) { char c = *it; if ( c == 'N' || c == 'n' || c == '?' ) { // Convert all ambiguity codes to N's *it = general_ambig; if (general_ambig == '?') ++number_of_questionmarks; else ++number_of_Ns; // ++number_of_DNARNA_amgibs; } ++it; } } else if (type == protein) { char * it = data.begin(); char * it_end = data.end(); number_of_questionmarks = 0; number_of_Xs = 0; while (it != it_end) { char c = *it; if ( c == 'X' || c == 'x' || c == '?' ) { // Convert all ambiguity codes to N's ++number_of_DNARNA_amgibs; *it = general_ambig; if (general_ambig == '?' ) ++number_of_questionmarks; else ++number_of_Xs; } ++it; } } // TODO: Adjust the numbers } void remove_gaps_stars_this_sequence(bool rg, bool rs) { // char *it = data.begin(); // char *it_end = data.end(); // TODO if (rg) {} if (rs) {} } void gaps_to_ambig_this_sequence() { char *it = data.begin(); char *it_end = data.end(); unsigned count=0; while (it != it_end) { if (*it =='-') { *it = general_ambig; ++count; } ++it; } // If residues are computed, we have to change the numbers counts for gaps and ambigs: if (numbers_of_residues_computed) { number_of_gaps -= count; // Should indeed be 0 now. if (general_ambig == 'N' || general_ambig == 'n') { number_of_Ns += count; } else if (general_ambig == 'X' || general_ambig == 'x') { number_of_Xs += count; } else if (general_ambig == '?') { number_of_questionmarks += count; } if (type == dna || type == rna) { ++number_of_DNARNA_amgibs += count; } } } void addCharToData(char c) { data.push_back(c); } // Reads line of data and removes only white spaces void getRawLine(CFile& infile) { register char c; c = infile.getchar(); while (!infile.fail() && c != '\n') { if ( isspace(c) ) // We remove white spaces. { c = infile.getchar(); continue; } addCharToData(c); c = infile.getchar(); } } void getRawLine(CFile& infile, unsigned &num) { register char c; unsigned local_num = 0; c = infile.getchar(); while (!infile.fail() && c != '\n') { if ( isspace(c) ) // We remove white spaces. { c = infile.getchar(); continue; } addCharToData(c); c = infile.getchar(); ++local_num; } num = local_num; } // Reads line of data and removes only white spaces void getRawLine_toupper(CFile& infile) { register char c; c = infile.getchar(); while (!infile.fail() && c != '\n') { if ( isspace(c) ) // We remove white spaces. { c = infile.getchar(); continue; } addCharToData(toupper(c)); c = infile.getchar(); } } // Called e.g. from Phobos void getLineOfDNA_toupper_ambig2N_removegaps (CFile& infile, unsigned &pos_in_seq) { register char c; unsigned pos = pos_in_seq; register char local_general_ambig = toupper(general_ambig); // ++pos; c = infile.getchar(); while (!infile.fail() && c != '\n') { // if the char is a space or something we do not count, we subtract this further below ++number_raw_original_length; c = toupper(c); if ( c == 'A' || c == 'T' || c == 'G' || c == 'C') { addCharToData(c); ++number_of_DNARNA_bases; } else if ( c == 'U') { addCharToData('U'); ++number_of_DNARNA_bases; ++number_of_Us; } else if ( c == 'R' || c == 'Y' || c == 'K' || c == 'M' || c == 'S' || c == 'W' || c == 'B' || c == 'D' || c == 'H' || c == 'V' ) { // Convert all ambiguity codes to N's addCharToData(local_general_ambig); ++number_of_DNARNA_amgibs; // includes N and '?' if (local_general_ambig == 'N') ++number_of_Ns; else ++number_of_questionmarks; } else if (c == '?' || c == 'N') { addCharToData(local_general_ambig); if (local_general_ambig == 'N') ++number_of_Ns; else ++number_of_questionmarks; ++number_of_DNARNA_amgibs; } else if ( isspace(c) ) { --number_raw_original_length; // we do not count spaces } // Spaces are removed else if ( c=='-' || c=='*') // What do we do with gaps and *s - Here they are removed, // but their positions are stored in order to able to reconstruct the original coordinates. { // I don't really know why we tolerate '*' ? They occur in protein sequences as stop codons. gap_and_star_koords.push_back(pos); // If we want to reconstruct the true position in the sequence, // we need to keep track of the positions we cut out. if (c=='-') { gap_koords.push_back(pos); ++number_of_gaps; } else { star_koords.push_back(pos); ++number_of_stars; } // c = infile.getchar(); // ++pos; } else { // we do not count this -just to be consistent before we bail out --number_raw_original_length; infile.clear(CFile::__fail_reason1 | CFile::__fail_flag); break; } c = infile.getchar(); ++pos; } pos_in_seq = pos; } void getLineOfDNA_generic (CFile& infile, unsigned &pos_in_seq, processing_flag pflag) { register char c; register char c_upper; register char local_general_ambig = general_ambig; unsigned pos = pos_in_seq; // register signed char delta; register bool convert_toupper_bool = (pflag & convert_toupper); // handled register bool convert_ambig2N_bool = (pflag & convert_ambig2N); // handled register bool removegaps_bool = (pflag & removegaps); // handled register bool removestars_bool = (pflag & removestars); // handled register bool gaps_to_ambig_bool = (pflag & gaps_to_ambig); // handled // In the routine calling this function it should be checked, that the general_ambig // character is upper or lower case, as specified. if (convert_toupper_bool) local_general_ambig = toupper(general_ambig); // ++pos; c = infile.getchar(); c_upper = toupper(c); while (!infile.fail() && c != '\n') { // if the char is a space or something we do not count, we subtract this further below ++number_raw_original_length; if (c >= 'a' && c <= 'z' && convert_toupper_bool) c = c_upper; if ( c_upper == 'A' || c_upper == 'T' || c_upper == 'G' || c_upper == 'C') { addCharToData(c); ++number_of_DNARNA_bases; } else if ( c_upper == 'U') { addCharToData(c); ++number_of_DNARNA_bases; ++number_of_Us; } else if (c_upper == 'R' || c_upper == 'Y' || c_upper == 'K' || c_upper == 'M' || c_upper == 'S' || c_upper == 'W' || c_upper == 'B' || c_upper == 'D' || c_upper == 'H' || c_upper == 'V' ) { if (convert_ambig2N_bool) { // Convert all ambiguity codes to N's, but we preserve the case. 'w' -> 'n' and 'W' -> 'N' etc. if (c <='Z') // i.e. lower case. addCharToData( tolower(local_general_ambig) ); else addCharToData( toupper(local_general_ambig) ); ++number_of_DNARNA_amgibs; // includes N and '?' if (local_general_ambig == '?' ) ++number_of_questionmarks; else ++number_of_Ns; } else { addCharToData(c); } } else if (c == '?' || c_upper == 'N') // c is either: 'N', 'n', '?' { ++number_of_DNARNA_amgibs; if (local_general_ambig == '?') { addCharToData(local_general_ambig); ++number_of_questionmarks; } else // c is '?' or 'N' or 'n' and general_ambig is 'N' or 'n' --- add 'N' or 'n' { ++number_of_Ns; if (c == '?') // convert to general ambig with proper case: { addCharToData(local_general_ambig); // Append general_ambig with appropriate case. } else // c is 'N' or 'n', general_ambig is 'N' or 'n' { addCharToData(c); // Append N or n and preserve case !!! to be consistent with the flags. } // Note: In case of: convert to upper, we have already converted c to upper. } } else if ( isspace(c) ) { --number_raw_original_length; // we do not count spaces } // Spaces are removed else if ( c=='-' || c=='*') // What do we do with gaps and *s - Here they are removed, // but their positions are stored in order to able to reconstruct the original coordinates. { // I don't really know why we tolerate '*' ? They occur in protein sequences as stop codons. if (c=='-') { if ( gaps_to_ambig_bool) { // std::cerr << "Gaps to ambig " << std::endl; addCharToData(local_general_ambig); if (general_ambig == '?' ) ++number_of_questionmarks; else ++number_of_Ns; ++number_of_DNARNA_amgibs; } else if ( removegaps_bool ) { // std::cerr << "Remove gaps " << std::endl; gap_and_star_koords.push_back(pos); // If we want to reconstruct the true position in the sequence, // we need to keep track of the positions we cut out. gap_koords.push_back(pos); ++number_of_gaps; } else { addCharToData('-'); ++number_of_gaps; } } else if (removestars_bool) { gap_and_star_koords.push_back(pos); // If we want to reconstruct the true position in the sequence, // we need to keep track of the positions we cut out. star_koords.push_back(pos); ++number_of_stars; } // c = infile.getchar(); // ++pos; } else { // we do not count this -just to be consistent before we bail out --number_raw_original_length; infile.clear(CFile::__fail_reason1 | CFile::__fail_flag); break; } c = infile.getchar(); c_upper = toupper(c); ++pos; } pos_in_seq = pos; } void getLineOfProtein_generic (CFile& infile, unsigned &pos_in_seq, processing_flag pflag) { register char c; register char c_upper; register char local_general_ambig = general_ambig; unsigned pos = pos_in_seq; // register signed char delta; register bool convert_toupper_bool = (pflag & convert_toupper); // handled // register bool convert_ambig2N_bool = (pflag & convert_ambig2N); // handled register bool removegaps_bool = (pflag & removegaps); // handled // register bool removestars_bool = (pflag & removestars); // handled register bool gaps_to_ambig_bool = (pflag & gaps_to_ambig);// handled // In the routine calling this function it should be checked, that the general_ambig // character is upper or lower case, as specified. if (convert_toupper_bool) local_general_ambig = toupper(general_ambig); // ++pos; c = infile.getchar(); c_upper = toupper(c); while (!infile.fail() && c != '\n') { // if the char is a space or something we do not count, we subtract this further below ++number_raw_original_length; if (c >= 'a' && c <= 'z' && convert_toupper_bool) c = c_upper; if (c == '?' || c_upper == 'X' ) { if (local_general_ambig == '?') { addCharToData(local_general_ambig); ++number_of_questionmarks; } else // c is '?' or 'X' or 'x' and general_ambig is 'X' or 'x' { ++number_of_Xs; if (c == '?') { addCharToData(local_general_ambig); } else // c is 'X' 'x', general_ambig is 'X' 'x' addCharToData(c); // Append X or x and preserve case !!! to be consistent with the flags. // Note: In case of convert to upper, we have already converted c to upper. } } else // The following code assumes we do not have X or ?. Otherwise Xs are duplicated in the data. if ( is_aa_or_aa_ambig_extended(c) ) // includes other ambigs (!'X', !'x' ,!'?') { addCharToData(c); ++number_of_AAs; // Counts ambigs but not X or ? } else if ( isspace(c) ) { --number_raw_original_length; // we do not count spaces } // Spaces are removed else if ( c=='-' || c=='*') // What do we do with gaps and *s - Here they are removed, // but their positions are stored in order to able to reconstruct the original coordinates. { // I don't really know why we tolerate '*' ? They occur in protein sequences as stop codons. if (c=='-') { if ( gaps_to_ambig_bool) { addCharToData(local_general_ambig); if (local_general_ambig == '?' ) ++number_of_questionmarks; else ++number_of_Xs; } else if ( removegaps_bool ) { gap_and_star_koords.push_back(pos); // If we want to reconstruct the true position in the sequence, // we need to keep track of the positions we cut out. gap_koords.push_back(pos); ++number_of_gaps; } else { addCharToData('-'); ++number_of_gaps; } } /* else if (removestars_bool) */ /* { */ /* gap_and_star_koords.push_back(pos); // If we want to reconstruct the true position in the sequence, */ /* // we need to keep track of the positions we cut out. */ /* star_koords.push_back(pos); */ /* ++number_of_stars; */ /* } */ // c = infile.getchar(); // ++pos; } else // Unknown symbol { // we do not count this -just to be consistent before we bail out --number_raw_original_length; infile.clear(CFile::__fail_reason2 | CFile::__fail_flag); break; } c = infile.getchar(); c_upper = toupper(c); ++pos; } pos_in_seq = pos; } void getLineOfDNA_toupper_removegaps (CFile& infile, unsigned &pos_in_seq) { register char c; unsigned pos = pos_in_seq; register char local_general_ambig = toupper(general_ambig); // ++pos; c = infile.getchar(); while (!infile.fail() && c != '\n') { // if the char is a space or something we do not count, we subtract this further below ++number_raw_original_length; c = toupper(c); if ( c == 'A' || c == 'T' || c == 'G' || c == 'C') { addCharToData(c); ++number_of_DNARNA_bases; } else if ( c == 'N' || c == '?') { addCharToData(local_general_ambig); if (general_ambig == 'N') ++number_of_Ns; else ++number_of_questionmarks; ++number_of_DNARNA_amgibs; // includes N and '?' } else if ( c == 'U') { addCharToData('U'); ++number_of_DNARNA_bases; ++number_of_Us; } else if ( c == 'R' || c == 'Y' || c == 'K' || c == 'M' || c == 'S' || c == 'W' || c == 'B' || c == 'D' || c == 'H' || c == 'V' ) { addCharToData(c); ++number_of_DNARNA_amgibs; } else if ( isspace(c) ) // Spaces are removed { --number_raw_original_length; // we do not count spaces } else if ( c=='-' || c=='*') // What do we do with gaps and *s - Here they are removed, but their positions are stored in order to reconstruct the original coordinates. { // I don't really know why we tolerate '*' ? gap_and_star_koords.push_back(pos); // If we want to reconstruct the true position in the sequence, // we need to keep track of the positions we cut out. if (c=='-') { gap_koords.push_back(pos); ++number_of_gaps; } else { star_koords.push_back(pos); ++number_of_stars; } // c = infile.getchar(); // ++pos; } else { // Something went wrong -> the last reading event from the file failed // -> we set the fail flag, this informs the user that something went wrong // We do not count this - just to be consistent before we bail out --number_raw_original_length; infile.clear(CFile::__fail_reason1 | CFile::__fail_flag); break; } c = infile.getchar(); ++pos; } pos_in_seq = pos; } void getLineOfProtein_toupper_removegaps (CFile& infile, unsigned &pos_in_seq) { register char c; unsigned pos = pos_in_seq; // ++pos; c = infile.getchar(); char local_general_ambig = toupper(general_ambig); while (!infile.fail() && c != '\n') { // if the char is a space or something we do not count, we subtract this further below ++number_raw_original_length; c = toupper(c); if (c == 'X' || c=='?') { addCharToData(local_general_ambig); if (local_general_ambig == 'X' ) ++number_of_Xs; else ++number_of_questionmarks; } else if (is_aa_or_aa_ambig_extended(c) ) { addCharToData(c); ++number_of_AAs; } else if ( isspace(c) )// Spaces are removed { --number_raw_original_length; // we do not count spaces } else if ( c=='-' || c=='*') // What do we do with gaps and *s - Here they are removed, but their positions are stored in order to reconstruct the original coordinates. { // I don't really know why we tolerate '*' ? gap_and_star_koords.push_back(pos); // If we want to reconstruct the true position in the sequence, // we need to keep track of the positions we cut out. if (c=='-') { gap_koords.push_back(pos); ++number_of_gaps; } else { star_koords.push_back(pos); ++number_of_stars; } } else { // we do not count this -just to be consistent before we bail out --number_raw_original_length; infile.clear(CFile::__fail_reason2 | CFile::__fail_flag); break; } c = infile.getchar(); ++pos; } pos_in_seq = pos; } void getLineOfDNA_toupper_ambig2N_gaps2ambig (CFile& infile) { register char c; c = infile.getchar(); while (!infile.fail() && c != '\n') { // if the char is a space or something we do not count, we subtract this further below ++number_raw_original_length; c = toupper(c); if ( c == 'A' || c == 'T' || c == 'G' || c == 'C') { addCharToData(c); ++number_of_DNARNA_bases; } else if ( c == 'N' || c == '?') { addCharToData(general_ambig); if (general_ambig == 'N') ++number_of_Ns; else ++number_of_questionmarks; ++number_of_DNARNA_amgibs; } else if ( c == 'U') { addCharToData('U'); ++number_of_DNARNA_bases; ++number_of_Us; } else if ( c == 'R' || c == 'Y' || c == 'K' || c == 'M' || c == 'S' || c == 'W' || c == 'B' || c == 'D' || c == 'H' || c == 'V' ) { // Convert all ambiguity codes to N's addCharToData(general_ambig); if (general_ambig == 'N') ++number_of_Ns; else ++number_of_questionmarks; ++number_of_DNARNA_amgibs; } else if (c=='-') { addCharToData(general_ambig); if (general_ambig == 'N') ++number_of_Ns; else ++number_of_questionmarks; ++number_of_DNARNA_amgibs; } else if ( isspace(c) ) // We remove white spaces. { // I don't really know why we tolerate '*' ? --number_raw_original_length; // we do not count spaces } else { // we do not count this -just to be consistent before we bail out --number_raw_original_length; infile.clear(CFile::__fail_reason1 | CFile::__fail_flag); return; } c = infile.getchar(); } } public: CSequence_Mol(DataTypesEnum dt, char p_general_ambig = '\0'): type(dt), general_ambig(p_general_ambig), numbers_of_residues_computed(false), bitcode_recoded(false) { data.reserve(10000); if (p_general_ambig == '\0') // Use the typical ambig character { if (dt == dna) general_ambig = 'N'; else if (dt == protein) general_ambig = 'X'; else general_ambig = '?'; } reset_numbers_of_residues(); } CSequence_Mol(DataTypesEnum dt, faststring name, faststring::size_t len, char p_general_ambig = '\0'): full_name(name),type(dt), general_ambig(p_general_ambig), numbers_of_residues_computed(false), bitcode_recoded(false) { if (len < faststring::npos) ++len; data.reserve(len); find_shortname_and_description(); if (p_general_ambig == '\0') // Use the typical ambig character { if (dt == dna) general_ambig = 'N'; else if (dt == protein) general_ambig = 'X'; else general_ambig = '?'; } reset_numbers_of_residues(); } //************************************************************************** // pos1 must be the first column starting with 0. // pos2 must be the index after the last column. // pos2-pos1 must be the number of bases that are copied to this sequence. //************************************************************************** CSequence_Mol(const CSequence_Mol& s, faststring::size_t pos1=0, faststring::size_t pos2 = faststring::npos): full_name(s.full_name), short_name(s.short_name), description(s.description), type(s.type), general_ambig(s.general_ambig), numbers_of_residues_computed(false), bitcode_recoded(s.bitcode_recoded) { if (pos1 == 0 && pos2 >= s.length() ) data = s.data; else { if (pos2 > s.length() ) pos2 = s.length(); if (pos1 >= pos2) { return; } data.assign(s.data, pos1, pos2-pos1); } } // Should only be applied to dna sequences void convert_ambig2N_this_sequence() { if ( !(type == dna || type == rna) ) return; // This is a DNA sequence: char * it = data.begin(); char * it_end = data.end(); while (it != it_end) { char c = *it; char c_upper = toupper(c); if ( c_upper == 'R' || c_upper == 'Y' || c_upper == 'K' || c_upper == 'M' || c_upper == 'S' || c_upper == 'W' || c_upper == 'B' || c_upper == 'D' || c_upper == 'H' || c_upper == 'V' ) { // Convert all ambiguity codes to N's *it = general_ambig; if (general_ambig == 'N' || general_ambig == 'n') ++number_of_Ns; else ++number_of_questionmarks; ++number_of_DNARNA_amgibs; } ++it; } } bool has_only_gaps() { char * it = data.begin(); char * it_end = data.end(); while (it != it_end) { if (*it != '-') return false; ++it; } return true; } bool has_only_ambigs() { char * it = data.begin(); char * it_end = data.end(); if (type == dna || type == rna) { while (it != it_end) { if (!is_DNA_ambig(*it)) return false; ++it; } return true; } else if (type == protein) { while (it != it_end) { if (!is_aa_ambig(*it)) return false; ++it; } return true; } else // This result is undefined, since the data type is not specified. { return false; } } bool has_only_ambigs_or_gap() { // std::cout << "Call to: has_only_ambigs_or_gap" << std::endl; char * it = data.begin(); char * it_end = data.end(); if (type == dna || type == rna) { // std::cout << "Datatype is dna or rna" << std::endl; while (it != it_end) { // std::cout << "Checking " << *it << std::endl; if ( !(is_DNA_ambig(*it) || *it == '-') ) { // std::cout << "Returning false." << std::endl; return false; } ++it; } // std::cout << "Returning true." << std::endl; return true; } else if (type == protein) { while (it != it_end) { if ( !(is_aa_ambig(*it) || *it == '-') ) return false; ++it; } return true; } else // This result is undefined, since the data type is not specified. { // std::cout << "Returning default false for unspecified type." << std::endl; return false; } } faststring::size_t length() const { return data.size(); } DataTypesEnum get_datatype() { return type; } faststring type_as_string() { if (type == dna) return faststring("DNA"); else if (type == rna) return faststring("RNA"); else if (type == protein) return faststring("Protein"); return "Unknown"; } void set_taxon_and_sequence(const faststring& taxonName, const faststring& seqData, DataTypesEnum datatype=auto_detect_type) { /* unsigned pos; */ if (numbers_of_residues_computed) { reset_numbers_of_residues(); } full_name = taxonName; find_shortname_and_description(); /* if ( (pos = taxonName.find(' '))!=faststring::npos) */ /* { */ /* short_name = taxonName.substr(0,pos+1); */ /* description = taxonName.substr(pos+1); */ /* } */ /* else */ /* { */ /* short_name = taxonName; */ /* description.clear(); */ /* } */ data = seqData; // // toupper_this_sequence(); // Should not be necessary: // compute_numbers_of_residues(); if (datatype == auto_detect_type || datatype == unknown) { auto_detect_datatype(); // std::cerr << "Data type: " << type_as_string() << std::endl; // std::cerr << "General ambig: " << general_ambig << std::endl; if (auto_detect_ambig_detect_conflict() ) { std::cerr << "Conflict in ambiguity code used in imported sequence." << std::endl; } } // std::cerr << "General ambig: " << general_ambig << std::endl; change_ambigs(); // remove_gaps_stars_this_sequence(true, true); // general_ambig = ambig; // type = t; } void set_taxon_and_random_DNA_sequence(const faststring& taxonName, unsigned len, double piA, double piC, double piG) { size_t pos; type = dna; general_ambig = '?'; data.clear(); data.reserve(len+1); reset_numbers_of_residues(); full_name = taxonName; if ( (pos = taxonName.find(' '))!=faststring::npos) { short_name = taxonName.substr(0,pos+1); description = taxonName.substr(pos+1); } else { short_name = taxonName; description.clear(); } // Compute random sequence: unsigned i; double z; double bA = piA; double bC = bA+piC; double bG = bC+piG; for (i=0; i 0.25 * 100 - false - DNA if (aa_stuff < 0.1*data.length() && DNARNA_stuff < 0.1*data.length() ) type = unknown; else if (aa_stuff > 0.25*DNARNA_stuff) { if (number_of_Us > 0) type = rna; else type = dna; } else { type = protein; } } bool auto_detect_ambig_detect_conflict() // Return true in case of ambig conflict, else false { if (!numbers_of_residues_computed) compute_numbers_of_residues(); if (type == protein) general_ambig = 'X'; else general_ambig = 'N'; if (number_of_questionmarks > 0) general_ambig = '?'; // Determine conlict: return ( number_of_questionmarks > 0 && (number_of_Xs > 0 || ((type==dna || type==rna) && number_of_Ns > 0))); } void assignSeq(faststring &newseq, processing_flag flag=(processing_flag)0) { data.assign(newseq); numbers_of_residues_computed = false; if (flag & compute_numbers_of_residues_flag) compute_numbers_of_residues(); else { reset_numbers_of_residues(); } } void maskSeq(const char *start, const char *end, char c) { char *pos = const_cast(start); while (pos != end) { *pos = c; ++pos; } } void maskSeq_tolower(const char *start, const char *end) { char *pos = const_cast(start); while (pos != end) { *pos = tolower(*pos); ++pos; } } faststring::size_t find_pos_first_symbol_not_in_alphabet(const char * alphabet=NULL) { if (alphabet == NULL) { if (type == dna) { alphabet = DNARNA_symbols; } else if (type == protein) { alphabet = aa_symbols; } else { return faststring::npos; } } return data.find_first_not_of(alphabet); } // Fills str with the sequence data, that contains gaps and stars, that had been removed // temporarily. void getSequence_fill_in_gaps_and_stars(faststring &str) { if (bitcode_recoded) backrecode_bitcode_sequence(); unsigned upos = 0; unsigned pos_in_gap_and_star_koords=0; unsigned pos_in_gap_koords=0; unsigned pos_in_star_koords=0; const char *pos = data.begin(); // const char *end = data.end(); unsigned N = gap_and_star_koords.size(); unsigned Ngaps = gap_koords.size(); unsigned Nstars = star_koords.size(); // unsigned left_this_line = char_per_line; str.clear(); if (N == 0 && Ngaps == 0 && Nstars == 0) { str = data; return; } unsigned N_all_char = data.size()+N; str.reserve(N_all_char); while (upos < N_all_char) { if (pos_in_gap_and_star_koords == N) break; if ( gap_and_star_koords.get_unckecked(pos_in_gap_and_star_koords) == upos ) { if ( pos_in_gap_koords < Ngaps && gap_koords.get_unckecked(pos_in_gap_koords) == upos ) // this is a gap { str.push_back('-'); ++pos_in_gap_koords; ++pos_in_gap_and_star_koords; } else if ( pos_in_star_koords < Nstars && star_koords.get_unckecked(pos_in_star_koords) == upos ) // this is a gap { str.push_back('*'); ++pos_in_star_koords; ++pos_in_gap_and_star_koords; } } else { str.push_back(*pos); ++pos; } ++upos; // --left_this_line; /* if (left_this_line == 0) */ /* { */ /* str.push_back('\n'); */ /* left_this_line = char_per_line; */ /* } */ } // copy rest without gaps and stars while (upos < N_all_char) { str.push_back(*pos); ++pos; ++upos; // --left_this_line; /* if (left_this_line == 0) */ /* { */ /* str.push_back('\n'); */ /* left_this_line = char_per_line; */ /* } */ } /* if (left_this_line != char_per_line) // We have already written a partial line */ /* str.push_back('\n'); */ } // Replace part of the sequence. pos1 and pos2 are in the destination sequence. // - erases region from pos1 to pos2 // pos1 is the first column pos2-pos1 is the number of bases that are removed, // i.e. pos2 is the column after the last column that is to be removed. // - insert s with full length. void replace_part_of_sequence(CSequence_Mol &s, unsigned pos1, unsigned pos2) { if (type != s.type) { std::cerr << "Critical warning: Replacing part of sequence with different data type." << std::endl; } data.replace(pos1, pos2-pos1, s.data); } void append_sequence(CSequence_Mol &s) { if (type != s.type) { std::cerr << "Critical warning: Appending sequence with different data type." << std::endl; } data.append(s.data); } void append_residue_unchecked(char c) { data.push_back(c); } void writeSequence_fill_in_gaps_and_stars(FILE *of, unsigned char_per_line=50) { if (bitcode_recoded) backrecode_bitcode_sequence(); unsigned upos = 0; unsigned pos_in_gap_and_star_koords=0; unsigned pos_in_gap_koords=0; unsigned pos_in_star_koords=0; const char *pos = data.begin(); // const char *end = data.end(); unsigned N = gap_and_star_koords.size(); unsigned Ngaps = gap_koords.size(); unsigned Nstars = star_koords.size(); unsigned left_this_line = char_per_line; unsigned N_all_char = data.size()+N; fprintf(of, ">%s\n", full_name.c_str()); while (upos < N_all_char) { if (pos_in_gap_and_star_koords == N) break; if ( gap_and_star_koords.get_unckecked(pos_in_gap_and_star_koords) == upos ) { if ( pos_in_gap_koords < Ngaps && gap_koords.get_unckecked(pos_in_gap_koords) == upos ) // this is a gap { putc('-', of); ++pos_in_gap_koords; ++pos_in_gap_and_star_koords; } else if ( pos_in_star_koords < Nstars && star_koords.get_unckecked(pos_in_star_koords) == upos ) // this is a gap { putc('*', of); ++pos_in_star_koords; ++pos_in_gap_and_star_koords; } } else { putc(*pos, of); ++pos; } ++upos; --left_this_line; if (left_this_line == 0) { putc('\n', of); left_this_line = char_per_line; } } while (upos < N_all_char) { putc(*pos, of); ++pos; ++upos; --left_this_line; if (left_this_line == 0) { putc('\n', of); left_this_line = char_per_line; } } if (left_this_line != char_per_line) // We have already written a partial line putc('\n', of); } void writeSequence(FILE *of, unsigned char_per_line=50) //const { writeSequence_fasta(of, 0, faststring::npos, full_name.c_str(), char_per_line); } void writeSequence_fasta(FILE *of, unsigned char_per_line=50) //const { writeSequence_fasta(of, 0, faststring::npos, full_name.c_str(), char_per_line); } void writeSequence(FILE *of, faststring::size_t pos_beg, faststring::size_t pos_end, const char *s_name, unsigned char_per_line=50) const { writeSequence_fasta(of, pos_beg, pos_end, s_name, char_per_line); } void writeSequence_fasta(FILE *of, faststring::size_t pos_beg, // 0 based faststring::size_t pos_end, // 0 based, stop index const char *s_name, faststring::size_t char_per_line=50) const { const char *beg = data.begin() + pos_beg; const char *end = data.begin() + pos_end; const char *tmp_end; /* if (bitcode_recoded) */ /* backrecode_bitcode_sequence(); */ if (pos_end == faststring::npos || end > data.end() ) end = data.end(); if (char_per_line == faststring::npos) char_per_line = data.length(); fprintf(of, ">%s\n", s_name); tmp_end = beg + char_per_line; if (tmp_end > end) tmp_end = end; while (beg < end) { fprintf(of, "%.*s\n", int(tmp_end - beg), beg); beg = tmp_end; tmp_end = beg + char_per_line; if (tmp_end > end) tmp_end = end; } } // Some programs do not accept too many Ns in a row. // This function export sequences so that N-regions are collapsed // to a maximum number of successive Ns. // USE WITH CAUTION: This function changes your sequence data!!! // The output is not identical to your original sequence data. void writeSequence_fasta_collaps_NX_regions(FILE *of, faststring::size_t char_per_line=50, faststring::size_t maximum_number_of_successive_NXs=100) { writeSequence_fasta_collaps_NX_regions(of, 0, faststring::npos, full_name.c_str(), char_per_line, maximum_number_of_successive_NXs); } void writeSequence_fasta_collaps_NX_regions(FILE *of, faststring::size_t pos_beg, // 0 based faststring::size_t pos_end, // 0 based , stop index const char *s_name, faststring::size_t char_per_line=50, faststring::size_t maximum_number_of_successive_NXs=100) const { const char *beg = data.begin() + pos_beg; const char *end = data.begin() + pos_end; // const char *tmp_end; /* if (bitcode_recoded) */ /* backrecode_bitcode_sequence(); */ if (pos_end == faststring::npos || end > data.end() ) end = data.end(); fprintf(of, ">%s\n", s_name); faststring::size_t chars_in_this_line=0; faststring::size_t tmp_succNs=0; while (beg != end) { char c = *beg; char c_toupper = toupper(c); if (c_toupper == 'N' || c_toupper == 'X') { ++tmp_succNs; if (tmp_succNs <= maximum_number_of_successive_NXs) // print the N or X { putc(c, of); ++chars_in_this_line; if (chars_in_this_line == char_per_line) { putc('\n', of); chars_in_this_line = 0; } } // unwritten else: do not print the N or X } else { putc(c, of); tmp_succNs = 0; ++chars_in_this_line; if (chars_in_this_line == char_per_line) { putc('\n', of); chars_in_this_line = 0; } } ++beg; } if (chars_in_this_line != 0) putc('\n', of); } void writeSequence_partial_fasta(FILE *of, faststring::size_t pos_beg, // 0 based faststring::size_t pos_end, // 0 based , stop index const char *s_name, faststring::size_t char_per_line=50, bool degap=true) const { const char *beg = data.begin() + pos_beg; const char *end = data.begin() + pos_end; /* if (bitcode_recoded) */ /* backrecode_bitcode_sequence(); */ if (pos_end == faststring::npos || end > data.end() ) end = data.end(); fprintf(of, ">%s\n", s_name); faststring::size_t chars_in_this_line=0; if (degap) { while (beg != end) { char c = *beg; if (c != '-') { putc(c, of); ++chars_in_this_line; if (chars_in_this_line == char_per_line) { putc('\n', of); chars_in_this_line = 0; } } // unwritten else: do not print - ++beg; } } else { while (beg != end) { putc(*beg, of); ++chars_in_this_line; if (chars_in_this_line == char_per_line) { putc('\n', of); chars_in_this_line = 0; } ++beg; } } } void writeSequence_fasta_filter_sites(FILE *of, std::vector &site_filter, int offset, // 0 if site_filter is 0 based, 1 if site_filter is 1 based const char *s_name, faststring::size_t char_per_line=50) const { const char *beg = data.begin(); const char *end = data.end(); /* if (bitcode_recoded) */ /* backrecode_bitcode_sequence(); */ fprintf(of, ">%s\n", s_name); faststring::size_t chars_in_this_line=0; int i=offset; { while (beg != end) { if (site_filter[i] != 0) { putc(*beg, of); ++chars_in_this_line; if (chars_in_this_line == char_per_line) { putc('\n', of); chars_in_this_line = 0; } } // Move on in sequence and site_filter vector ++beg; ++i; } } } void writeSequence_phylip(FILE *of, faststring::size_t pos_beg, // 0 based faststring::size_t pos_end, // 0 based, stop index. const char *s_name) const { /* if (bitcode_recoded) */ /* backrecode_bitcode_sequence(); */ const char *beg = data.begin() + pos_beg; // const char *end = data.begin() + pos_end; /* if (pos_end == faststring::npos || end > data.end() ) */ /* end = data.end(); */ unsigned name_len = strlen(s_name); if (name_len < 11) fprintf(of, "%-10.10s", s_name); /* else */ /* { */ /* char str[11]; */ /* std::strncpy(str, s_name, 10); */ /* str[10] = '\0'; */ /* fprintf(of, "%s", str); */ /* } */ fprintf(of, "%.*s\n", pos_end - pos_beg, beg); } // Expects 0 bases coordinates. The range starts at pos_beg and pos_end // points to the base after the last position in the range. // Clearly pos_end > pos_beg. In the empty range, pos_end = pos_beg+1. void writeSequence_revComp(FILE *of, faststring::size_t pos_beg, // 0 based index faststring::size_t pos_end, // 0 based index after the last pos. const char *s_name, faststring::size_t char_per_line=50) const { /* if (bitcode_recoded) */ /* backrecode_bitcode_sequence(); */ const char *beg = data.begin() + pos_beg; const char *end = data.begin() + pos_end; faststring::size_t interleaved = char_per_line; fprintf(of, ">%s\n", s_name); // Walking backwards, we shift the range: --beg; // 0 based indices. beg is the rend index. Move beg to pos before "first pos". This is the stop index. --end; // 0 based index. Move end to index at which we start to move. // Example: Print first 3 bases. // Then: pos_beg=0, pos_end=3, 0 based, pos_end is index behind last pos in range. // Thus: beg="-1+seq_beg" and end="2+seq_beg", so print 2, 1, 0, and stop at -1 for (; beg < end; --end) { if (interleaved == 0) { fputc('\n', of); interleaved = char_per_line; } fputc( complementBase(*end), of ); // From CDnaString.h --interleaved; } fputc('\n', of); } unsigned baseComposition(std::vector &v) const { if ( v.size() < 256 ) { std::cerr << "Internal error. -24" << std::endl; exit(0); } char *pos = data.begin(); char *end = data.end(); faststring::size_t len = end - pos; while (pos != end) { ++v[*pos]; ++pos; } return len; } void sliding_window_CG_AT_content(std::vector &v, unsigned window_size) { char *end = data.end(); const char *range_beg = data.begin(); const char *range_end; double CG_prop; unsigned CG_num; unsigned AT_num; while (1) { range_end = range_beg + window_size; if (range_end > end) range_end = end; if (range_end == range_beg) break; CG_AT_content_in_region(range_beg, range_end, AT_num, CG_num); // std::cerr << AT_num << " " << CG_num << std::endl; if (CG_num == 0 && AT_num == 0) // e.g. if all chars are ambigs CG_prop = -1; else CG_prop = (double)CG_num/(CG_num+AT_num); v.push_back(CG_prop); range_beg = range_end; } } unsigned long long AsciiComposition_CpG_CpNpG(unsigned long long v[], unsigned long long &CpG, unsigned long long &CpNpG, unsigned long long &Nislands) const { char *pos = data.begin(); char *end = data.end(); char last = 'N'; // An island is not counted if located at the beginning or end of the sequence. unsigned long long len = end - pos; end = end - 2; while (pos < end) { char c1 = *pos; if ( c1 == 'C' || c1 == 'c' ) { char c2 = *(pos+1); char c3 = *(pos+2); if ( c2 == 'G' || c2 == 'g') ++CpG; if ( c3 == 'G' || c3 == 'g') ++CpNpG; } if (c1 == 'N' && last != 'N') ++Nislands; ++v[(int)c1]; ++pos; last = c1; } // Now deal with the second last position: if (len > 1 ) { char c1 = *pos; if ( c1 == 'C' || c1 == 'c' ) { char c2 = *(pos+1); if ( c2 == 'G' || c2 == 'g' ) ++CpG; } if (c1 == 'N' && last != 'N') ++Nislands; ++v[(int)c1]; ++pos; last = c1; } // Now deal with the last position: if (len > 0) { ++v[(int)*pos]; if (*pos == 'N') // We don't count the island if at the end of the sequence { if (last == 'N') // it has already been counted so undo this { --Nislands; } // else // we don't count it } } return len; } void debug_print_gap_coords(std::ostream &os) { unsigned *git = gap_and_star_koords.begin(); os << "Gap positions:" << std::endl; for (; git < gap_and_star_koords.end(); ++git) os << *git << std::endl; } faststring::size_t getSeqCoord(const char *seq_pos) { return seq_pos - data.begin() + 1; } char get_ambiguity_character() { return general_ambig; } faststring::size_t getSeqCoord_gap_correted(const char *seq_pos, faststring::size_t &seq_gap_offset) { faststring::size_t corrected_pos = seq_pos - data.begin()+1+seq_gap_offset; faststring::size_t i = seq_gap_offset; faststring::size_t N = gap_and_star_koords.size(); // std::cerr << "Entering getSeqCoord_gap_correted i: " << i << " N: " << N << " corr coord: " << corrected_pos << std::endl; while (i < N && gap_and_star_koords.get_unckecked(i) < corrected_pos) { ++i; ++corrected_pos; } seq_gap_offset = i; // std::cerr << "Exiting getSeqCoord_gap_correted i: " << i << " : " << N << " corr coord: " << corrected_pos << std::endl; return corrected_pos; } void writeSequence(std::ostream &os, faststring::size_t char_per_line) { char *pos = data.begin(); char *end = data.end(); char *tmp_end; if (bitcode_recoded) backrecode_bitcode_sequence(); os << ">" << full_name.c_str() << std::endl; // os << ">" << full_name.c_str() << std::endl; tmp_end = pos + char_per_line; if (tmp_end > end) tmp_end = end; while (pos != end) { while (pos != tmp_end) { os << *pos; ++pos; } os << std::endl; tmp_end = pos + char_per_line; if (tmp_end > end) tmp_end = end; } } /* void set_to_using_phylip_sequential_sequence() */ /* { */ /* } */ void readRawFastaSequence(CFile& infile, faststring::size_t &num) { char c = '\0'; bool first_line = true; full_name = ""; data.clear(); reset_numbers_of_residues(); c = infile.getchar(); while (!infile.fail() && isspace(c)) // Ignore spaces c = infile.getchar(); while (!infile.fail() && c == '#') // Ignore lines starting with # { infile.ignore('\n'); c = infile.getchar(); while (!infile.fail() && isspace(c) ) // Ignore spaces c = infile.getchar(); } if (c != '>') // Should be new sequence { infile.clear(CFile::__fail_flag); return; } infile.getline(full_name); if (infile.fail()) { return; } find_shortname_and_description(); c = infile.peekchar(); while ( !infile.fail() && c != '>' ) { // cerr << data.capacity() << endl; if (first_line) getRawLine(infile, num); else getRawLine(infile); first_line = false; c = infile.peekchar(); } } void readRawFastaSequence(CFile& infile) { char c = '\0'; full_name = ""; data.clear(); reset_numbers_of_residues(); c = infile.getchar(); while (!infile.fail() && isspace(c)) // Ignore spaces c = infile.getchar(); while (!infile.fail() && c == '#') // Ignore lines starting with # { infile.ignore('\n'); c = infile.getchar(); while (!infile.fail() && isspace(c) ) // Ignore spaces c = infile.getchar(); } if (c != '>') // Should be new sequence { infile.clear(CFile::__fail_flag); return; } infile.getline(full_name); if (infile.fail()) { return; } find_shortname_and_description(); c = infile.peekchar(); while ( !infile.fail() && c != '>' ) { // cerr << data.capacity() << endl; getRawLine(infile); c = infile.peekchar(); } } void readSeqName_ignore_Sequence_data(CFile& infile) { char c = '\0'; full_name = ""; data.clear(); reset_numbers_of_residues(); c = infile.getchar(); while (!infile.fail() && isspace(c)) // Ignore spaces c = infile.getchar(); while (!infile.fail() && c == '#') // Ignore lines starting with # { infile.ignore('\n'); c = infile.getchar(); while (!infile.fail() && isspace(c) ) // Ignore spaces c = infile.getchar(); } if (c != '>') // Should be new sequence { infile.clear(CFile::__fail_flag); return; } infile.getline(full_name); if (infile.fail()) { return; } find_shortname_and_description(); // Ignore the sequence data of this sequence: c = infile.peekchar(); while ( !infile.fail() && c != '>' ) { // std::cerr << data.capacity() << std::endl; infile.ignore('\n'); c = infile.peekchar(); } } void readRawFastaSequence_toupper(CFile& infile) { char c = '\0'; full_name = ""; data.clear(); reset_numbers_of_residues(); c = infile.getchar(); while (!infile.fail() && isspace(c)) c = infile.getchar(); while (!infile.fail() && c == '#') { infile.ignore('\n'); c = infile.getchar(); while (!infile.fail() && isspace(c) ) c = infile.getchar(); } if (c != '>') { infile.clear(CFile::__fail_flag); return; } infile.getline(full_name); if (infile.fail()) { return; } find_shortname_and_description(); c = infile.peekchar(); while ( !infile.fail() && c != '>' ) { // std::cerr << data.capacity() << std::endl; getRawLine_toupper(infile); c = infile.peekchar(); } } // it1 is the first position to fill. This cooridnate must be 0 based. // it2 is the position behind the last position to fill. It must be 0 based. void fill_range_with(faststring::size_t pos1, faststring::size_t pos2, char c) { numbers_of_residues_computed = false; char *it1 = data.begin() + pos1; char *it2 = data.begin() + pos2; char *it_end = data.end(); if (it2 > it_end) it2 = it_end; while (it1 < it2) { *it1 = c; ++it1; } } // Called from Phobos: // TODO: I think we should not remove stars any more. // Stars should only be tolerated in protein sequences. void readFastaSequence_toupper_ambig2N_removegaps(CFile& infile) { char c = '\0'; faststring::size_t pos = 0; full_name = ""; data.clear(); gap_and_star_koords.clear(); gap_koords.clear(); star_koords.clear(); reset_numbers_of_residues(); c = infile.getchar(); while (!infile.fail() && isspace(c)) c = infile.getchar(); while (!infile.fail() && c == '#') { infile.ignore('\n'); c = infile.getchar(); while (!infile.fail() && isspace(c) ) c = infile.getchar(); } if (c != '>') { infile.clear(CFile::__fail_flag); return; } infile.getline(full_name); if (infile.fail()) { return; } find_shortname_and_description(); c = infile.peekchar(); while ( !infile.fail() && c != '>' ) { // std::cerr << data.capacity() << std::endl; if (type == dna) getLineOfDNA_toupper_ambig2N_removegaps(infile, pos); else std::cout << "Not implemented. Use the readFastaSequence_toupper_removegaps(CFile& infile) function instead." << std::endl; c = infile.peekchar(); } } void readFastaSequence_toupper_removegaps(CFile& infile) { char c = '\0'; faststring::size_t pos = 0; full_name = ""; data.clear(); gap_and_star_koords.clear(); gap_koords.clear(); star_koords.clear(); reset_numbers_of_residues(); c = infile.getchar(); while (!infile.fail() && isspace(c)) c = infile.getchar(); while (!infile.fail() && c == '#') { infile.ignore('\n'); c = infile.getchar(); while (!infile.fail() && isspace(c) ) c = infile.getchar(); } if (c != '>') { infile.clear(CFile::__fail_flag); return; } infile.getline(full_name); if (infile.fail()) { return; } find_shortname_and_description(); c = infile.peekchar(); while ( !infile.fail() && c != '>' ) { // std::cerr << data.capacity() << std::endl; if (type == dna) getLineOfDNA_toupper_removegaps(infile, pos); else getLineOfProtein_toupper_removegaps(infile, pos); c = infile.peekchar(); } } // Backward compatible function: // Called e.g. from Phobos void readFastaSequence_toupper_ambig2N_gaps2N(CFile& infile) { readFastaSequence_toupper_ambig2N_gaps2ambig(infile); } // Has recently been renamed: gaps2N -> gaps2ambig // since we want to prepare for reading proteins. void readFastaSequence_toupper_ambig2N_gaps2ambig(CFile& infile) { char c = '\0'; full_name = ""; data.clear(); reset_numbers_of_residues(); c = infile.getchar(); while (!infile.fail() && isspace(c)) c = infile.getchar(); while (!infile.fail() && c == '#') { infile.ignore('\n'); c = infile.getchar(); while (!infile.fail() && isspace(c) ) c = infile.getchar(); } if (c != '>') { infile.clear(CFile::__fail_flag); return; } infile.getline(full_name); if (infile.fail()) { return; } find_shortname_and_description(); c = infile.peekchar(); while ( !infile.fail() && c != '>' ) { // std::cerr << data.capacity() << std::endl; if (type == dna) getLineOfDNA_toupper_ambig2N_gaps2ambig(infile); else std::cout << "Not implemented." << std::endl; c = infile.peekchar(); } } void recode_sequence_to_bitcode() { if (type == dna) { char *it = data.begin(); char *it_end = data.end(); while (it != it_end) { *it = recode_DNA(*it); ++it; } bitcode_recoded = true; } else if (type == protein) {} } void backrecode_bitcode_sequence() { if (type == dna) { char *it = data.begin(); char *it_end = data.end(); while (it != it_end) { *it = backrecode_DNA(*it); ++it; } bitcode_recoded = false; } else if (type == protein) {} } // Crashed in this function on linux - do not know why yet 64 bit problem?? void check_allowed_symbols_in_sequence(const char *symbols) { size_t pos=0; pos = data.find_first_not_of(symbols, pos); while (pos != faststring::npos) { std::cerr << "Found illegal symbol in sequence: " << short_name << " Position " << pos << ". Found char " << data[pos] << std::endl; ++pos; pos = data.find_first_not_of(symbols, pos); } } void export_fasta() { } void export_phylip() { } void export_nexus() { } void readFastaSequence_generic(CFile& infile, processing_flag pflag) { char c = '\0'; faststring::size_t pos = 0; // TODO: Prepare to remove gaps and/or stars: // Increase the readability: register bool convert_toupper_bool = (pflag & convert_toupper); // register bool convert_ambig2N_bool = (pflag & convert_ambig2N); // register bool removegaps_bool = (pflag & removegaps); // register bool removestars_bool = (pflag & removestars); // bool gaps_to_ambig_bool = (pflag & gaps_to_ambig); // full_name = ""; data.clear(); reset_numbers_of_residues(); c = infile.getchar(); while (!infile.fail() && isspace(c)) c = infile.getchar(); while (!infile.fail() && c == '#') { infile.ignore('\n'); c = infile.getchar(); while (!infile.fail() && isspace(c) ) c = infile.getchar(); } if (c != '>') { infile.clear(CFile::__fail_flag); return; } infile.getline(full_name); if (infile.fail()) { return; } find_shortname_and_description(); c = infile.peekchar(); while ( !infile.fail() && c != '>' ) { // std::cerr << data.capacity() << std::endl; if (type == dna) getLineOfDNA_generic(infile, pos, pflag); else if (type == protein) getLineOfProtein_generic(infile, pos, pflag); else if (type == molecular) { getRawLine(infile); if (convert_toupper_bool) toupper_this_sequence(); if (convert_ambig2N_bool) convert_ambig2N_this_sequence(); if (gaps_to_ambig_bool) gaps_to_ambig_this_sequence(); if (removegaps_bool || removestars_bool) remove_gaps_stars_this_sequence(removegaps_bool, removestars_bool); } else if (type == auto_detect_type) { getRawLine(infile); if (convert_toupper_bool) toupper_this_sequence(); auto_detect_datatype(); if (convert_ambig2N_bool) convert_ambig2N_this_sequence(); if (gaps_to_ambig_bool) gaps_to_ambig_this_sequence(); if (removegaps_bool || removestars_bool) remove_gaps_stars_this_sequence(removegaps_bool, removestars_bool); } c = infile.peekchar(); } } unsigned get_number_of_Ns() { if (!numbers_of_residues_computed) compute_numbers_of_residues(); return number_of_Ns; } unsigned get_number_of_gaps() { if (!numbers_of_residues_computed) compute_numbers_of_residues(); return number_of_gaps; } unsigned get_number_raw_original_length() { if (!numbers_of_residues_computed) compute_numbers_of_residues(); return number_raw_original_length; } unsigned get_number_of_DNARNA_bases() { if (!numbers_of_residues_computed) compute_numbers_of_residues(); return number_of_DNARNA_bases; } unsigned get_number_of_AAs() { if (!numbers_of_residues_computed) compute_numbers_of_residues(); return number_of_AAs; } unsigned get_number_of_DNARNA_ambigs() { return number_of_DNARNA_amgibs; } double get_CG_content() { // std::cerr << "number_CG " << number_CG << std::endl; // std::cerr << "number_of_DNARNA_bases " << number_of_DNARNA_bases << std::endl; // // std::cerr << "number_of_DNARNA_amgibs " << number_of_DNARNA_amgibs << std::endl; return ((double) number_CG)/(number_of_DNARNA_bases); } bool range_contains_gaps_or_Ns(faststring::size_t pos1, faststring::size_t pos2) { faststring::size_t len = length(); if (pos1 >= pos2 || pos1 > len) // Empty range return false; if (pos2 > len) pos2 = len; const char *p1, *p2; p1 = getSeqBegin() + pos1; p2 = getSeqBegin() + pos2; char c='\0'; while (p1 != p2) { c = *p1; if (c == 'N' || c == 'n' || c == '-') break; ++p1; } if (c == 'N' || c == 'n' || c == '-') return true; else return false; } // Requirement: Amino acids have to encoded as upper case characters. // Returns -1 in case the sequence is not proper blosum code. // Returns 0 or positive value indicating the number of Js that have been replaced. int check_protein_sequence_for_blosum_compatibility(unsigned &refpos) { unsigned pos; int count = data.replace_char_count('J','X'); bool OK = is_aa_blosum_code_or_gap_sequence(data.begin(), data.end(), &pos); if (!OK) { refpos = pos; return -1; } return count; } // void readFastaSequence(CFile& infile) is deprecated: // Use one of the other read functions below. // This function used to by of type // toupper_ambig2N_removegaps /* void readFastaSequence(CFile& infile) */ /* { */ /* #warning "The readFastaSequence function is deprecated." */ /* char c = '\0'; */ /* full_name = ""; */ /* data.clear(); */ /* c = infile.getchar(); */ /* while (!infile.fail() && isspace(c)) */ /* c = infile.getchar(); */ /* while (!infile.fail() && c == '#') */ /* { */ /* infile.ignore('\n'); */ /* c = infile.getchar(); */ /* while (!infile.fail() && isspace(c) ) */ /* c = infile.getchar(); */ /* } */ /* if (c != '>') */ /* { */ /* infile.clear(CFile::__fail_flag); */ /* return; */ /* } */ /* infile.getline(full_name); */ /* if (infile.fail()) */ /* { */ /* return; */ /* } */ /* find_shortname_and_description(); */ /* c = infile.peekchar(); */ /* while ( !infile.fail() && c != '>' ) */ /* { */ /* // cerr << data.capacity() << endl; */ /* if (type == dna) */ /* getLineOfDNA_toupper_ambig2N_removegaps(infile); */ /* else */ /* std::cout << "Not implemented." << std::endl; */ /* c = infile.peekchar(); */ /* } */ /* } */ }; // Functions provided to read sequences: // void readRawFastaSequence(CFile& infile) // No character checks // void readRawFastaSequence_toupper(CFile& infile) // No character checks // void readFastaSequence_toupper_ambig2N_removegaps(CFile& infile) // // void readFastaSequence_toupper_ambig2N_gaps2ambig(CFile& infile) // // void readFastaSequence_toupper_removegaps(CFile& infile) // In Arbeit // #endif