42 return GBS_global_string(
"Species '%s' has no data in alignment '%s'", name, ali_name);
49 x = (
int) floor(value);
66 return ta.
close(error);
76 {
"number_of_bases",
GB_INT },
77 {
"percent_of_bases",
GB_INT },
81 {
"number_of_no_helix",
GB_INT },
82 {
"number_of_weak_helix",
GB_INT },
83 {
"number_of_strong_helix",
GB_INT },
86 {
"percent_base_deviation",
GB_INT },
87 {
"percent_GC_difference",
GB_INT },
89 {
"consensus_conformity/name",
GB_STRING },
90 {
"consensus_conformity/value",
GB_FLOAT },
91 {
"consensus_conformity/num_species",
GB_INT },
93 {
"consensus_deviation/name",
GB_STRING },
94 {
"consensus_deviation/value",
GB_FLOAT },
95 {
"consensus_deviation/num_species",
GB_INT },
97 {
"consensus_evaluated",
GB_INT },
106 for (
int i = 0; keys2add[i].key && !
error; ++i) {
107 const char *fullkey =
GBS_global_string(
"quality/%s/%s", alignment_name, keys2add[i].key);
122 for (
GBDATA *gb_species = getFirst(gb_main); gb_species && !
error; gb_species = getNext(gb_species)) {
132 if (!gb_quality_ali) {
133 error =
GBS_global_string(
"No alignment entry '%s' in quality data", alignment_name);
141 double result = bases<4 ? 0 : (bases<6 ? 1 : 2);
142 if (result != 0) result = (result * weights.
bases) / 2;
151 if (dfa < 2) result = 5;
152 else if (dfa < 4) result = 4;
153 else if (dfa < 6) result = 3;
154 else if (dfa < 8) result = 2;
155 else if (dfa < 10) result = 1;
165 if (noh < 20) result = 5;
166 else if (noh < 50) result = 4;
167 else if (noh < 125) result = 3;
168 else if (noh < 250) result = 2;
169 else if (noh < 500) result = 1;
172 if (result != 0) result = (result * weights.
helix) / 5;
180 if (result != 0) result = (result * weights.
consensus) / 12;
187 if (iupv < 1) result = 3;
188 else if (iupv < 5) result = 2;
189 else if (iupv < 10) result = 1;
192 if (result != 0) result = (result * weights.
iupac) / 3;
199 if (gcprop < 1) result = 5;
200 else if (gcprop < 2) result = 4;
201 else if (gcprop < 4) result = 3;
202 else if (gcprop < 8) result = 2;
203 else if (gcprop < 16) result = 1;
206 if (result != 0) result = (result * weights.
gc) / 5;
221 free(alignment_name);
226 char *filteredSequence =
NULp;
235 ARB_alloc(filteredSequence, filteredLength);
236 if (filteredSequence) {
237 for (
int i = 0; i < filteredLength; ++i) {
238 filteredSequence[i] = rawSequence[filterpos_2_seqpos[i]];
242 return filteredSequence;
311 free(alignment_name);
342 read_sequence =
GB_entry(gb_ali,
"data");
387 free(alignment_name);
425 int diff_percent = 0;
427 if (avg_bases != 0) {
428 double diff = bases - avg_bases;
429 diff = (100 *
diff) / avg_bases;
446 int diff_percent = 0;
449 double diff = gcp - avg_gc;
450 diff = (100 *
diff) / avg_gc;
471 int whilecounter = 0;
476 SQ_GroupDataDictionary::iterator GDI =
group_dict.find(backup->
name);
484 int value3 = GD_ptr->SQ_get_nr_sequences();
509 if (value1 > 0.95) eval += 5;
510 else if (value1 > 0.8) eval += 4;
511 else if (value1 > 0.6) eval += 3;
512 else if (value1 > 0.4) eval += 2;
513 else if (value1 > 0.25) eval += 1;
516 if (value2 > 0.6) eval += 0;
517 else if (value2 > 0.4) eval += 1;
518 else if (value2 > 0.2) eval += 2;
519 else if (value2 > 0.1) eval += 3;
520 else if (value2 > 0.05) eval += 4;
521 else if (value2 > 0.025) eval += 5;
522 else if (value2 > 0.01) eval += 6;
529 backup = backup->get_father();
535 eval = eval / whilecounter;
548 free(alignment_name);
576 read_sequence =
GB_entry(gb_ali,
"data");
590 int diff_percent = 0;
592 if (avg_bases != 0) {
593 double diff = bases - avg_bases;
594 diff = (100 *
diff) / avg_bases;
611 int diff_percent = 0;
614 double diff = gcp - avg_gc;
615 diff = (100 *
diff) / avg_gc;
665 if (value1 > 0.95) eval += 5;
666 else if (value1 > 0.8) eval += 4;
667 else if (value1 > 0.6) eval += 3;
668 else if (value1 > 0.4) eval += 2;
669 else if (value1 > 0.25) eval += 1;
672 if (value2 > 0.6) eval += 0;
673 else if (value2 > 0.4) eval += 1;
674 else if (value2 > 0.2) eval += 2;
675 else if (value2 > 0.1) eval += 3;
676 else if (value2 > 0.05) eval += 4;
677 else if (value2 > 0.025) eval += 5;
678 else if (value2 > 0.01) eval += 6;
683 if (eval != 0) evaluation =
sq_round(eval);
697 free(alignment_name);
712 error =
SQ_pass1(data, gb_main, node, filter);
716 TreeNode *node1 = node->get_leftson();
717 TreeNode *node2 = node->get_rightson();
721 bool parentIsEmpty =
false;
724 parentIsEmpty =
true;
728 leftData = data->
clone();
737 if (!parentIsEmpty) data->
SQ_add(*leftData);
748 if (!error) error =
SQ_pass1_on_tree(node2, gb_main, data, filter, progress);
764 error =
SQ_pass2(data, gb_main, node, filter);
796 for (
GBDATA *gb_species = getFirst(gb_main); gb_species; gb_species = getNext(gb_species)) {
803 read_sequence =
GB_entry(gb_ali,
"data");
806 if (gb_quality_ali) {
810 if (result < condition) marked =
true;
821 free(alignment_name);
static GB_ERROR no_data_error(GBDATA *gb_species, const char *ali_name)
static char * SQ_fetch_filtered_sequence(GBDATA *read_sequence, AP_filter *filter)
static GB_ERROR SQ_pass2(const SQ_GroupData *globalData, GBDATA *gb_main, TreeNode *node, AP_filter *filter)
const size_t * get_filterpos_2_seqpos() const
GBDATA * GBT_first_marked_species(GBDATA *gb_main)
long GB_read_int(GBDATA *gbd)
GB_ERROR GB_write_string(GBDATA *gbd, const char *s)
bool SQ_is_initialized() const
GB_ERROR SQ_add_changekeys(GBDATA *gb_main, const char *alignment_name)
GB_ERROR SQ_pass2_on_tree(TreeNode *node, GBDATA *gb_main, const SQ_GroupData *data, AP_filter *filter, arb_progress &progress)
const char * GBS_global_string(const char *templat,...)
virtual void SQ_add_sequence(const char *sequence)=0
static char * alignment_name
void SQ_calc_physical_layout(const char *sequence, int size, GBDATA *gb_quality_ali)
void SQ_count_ambiguities(const char *iupac, int length, GBDATA *gb_quality)
static int sq_round(double value)
void SQ_count_sequences()
std::map< std::string, SQ_GroupDataPtr > SQ_GroupDataDictionary
GB_ERROR GB_delete(GBDATA *&source)
virtual consensus_result SQ_calc_consensus(const char *sequence) const =0
GB_ERROR GBT_add_new_species_changekey(GBDATA *gb_main, const char *name, GB_TYPES type)
static int diff(int v1, int v2, int v3, int v4, int st, int en)
TYPE * ARB_alloc(size_t nelem)
void SQ_calc_helix_layout(const char *sequence, GBDATA *gb_main, char *alignment_name, GBDATA *gb_quality, AP_filter *filter)
virtual SQ_GroupData * clone() const =0
int SQ_get_avg_bases() const
static void create_multi_level_consensus(TreeNode *node, SQ_GroupData *data)
GB_ERROR SQ_mark_species(GBDATA *gb_main, int condition, bool marked_only)
GB_ERROR SQ_pass2_no_tree(const SQ_GroupData *globalData, GBDATA *gb_main, AP_filter *filter, arb_progress &progress)
void SQ_clear_group_dictionary()
static int weights[MAX_BASETYPES][MAX_BASETYPES]
void SQ_set_avg_bases(int bases)
static void error(const char *msg)
GB_ERROR SQ_pass1_on_tree(TreeNode *node, GBDATA *gb_main, SQ_GroupData *data, AP_filter *filter, arb_progress &progress)
GBDATA * GBT_next_marked_species(GBDATA *gb_species)
CONSTEXPR_INLINE_Cxx14 void swap(unsigned char &c1, unsigned char &c2)
float GB_read_float(GBDATA *gbd)
int GB_read_flag(GBDATA *gbd)
virtual void SQ_add(const SQ_GroupData &other)=0
GB_ERROR GB_write_float(GBDATA *gbd, float f)
GB_ERROR GB_write_int(GBDATA *gbd, long i)
size_t get_filtered_length() const
GB_ERROR SQ_pass1_no_tree(SQ_GroupData *globalData, GBDATA *gb_main, AP_filter *filter, arb_progress &progress)
double SQ_get_gc_proportion() const
int SQ_get_number_of_bases() const
static GB_ERROR SQ_pass1(SQ_GroupData *globalData, GBDATA *gb_main, TreeNode *node, AP_filter *filter)
int SQ_get_nr_sequences() const
GB_ERROR close(GB_ERROR error)
void GB_write_flag(GBDATA *gbd, long flag)
GB_ERROR SQ_evaluate(GBDATA *gb_main, const SQ_weights &weights, bool marked_only)
virtual void SQ_init_consensus(int size)=0
GBDATA * GBT_first_species(GBDATA *gb_main)
void SQ_set_avg_gc(double gc)
GBDATA * GBT_next_species(GBDATA *gb_species)
double SQ_get_avg_gc() const
static SQ_GroupDataDictionary group_dict
SQ_TREE_ERROR SQ_check_tree_structure(TreeNode *node)
char * GBT_get_default_alignment(GBDATA *gb_main)
GB_transaction ta(gb_var)
GB_CSTR GB_read_char_pntr(GBDATA *gbd)
GBDATA *(* species_iterator)(GBDATA *)
GBDATA * GB_search(GBDATA *gbd, const char *fieldpath, GB_TYPES create)
GB_ERROR SQ_remove_quality_entries(GBDATA *gb_main)
GBDATA * GB_entry(GBDATA *father, const char *key)
void inc_and_check_user_abort(GB_ERROR &error)