source: tags/arb-6.0-rc1/SEQ_QUALITY/SQ_main.cxx

Last change on this file was 11512, checked in by westram, 10 years ago
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.0 KB
Line 
1//  ==================================================================== //
2//                                                                       //
3//    File      : SQ_main.cxx                                            //
4//    Purpose   : Entrypoint to Seq. Quality analysis; calls functions   //
5//                                                                       //
6//                                                                       //
7//  Coded by Juergen Huber in July 2003 - February 2004                  //
8//  Coded by Kai Bader (baderk@in.tum.de) in 2007 - 2008                 //
9//  Copyright Department of Microbiology (Technical University Munich)   //
10//                                                                       //
11//  Visit our web site at: http://www.arb-home.de/                       //
12//                                                                       //
13//  ==================================================================== //
14
15#include "seq_quality.h"
16#include "SQ_functions.h"
17
18#include <awt_filter.hxx>
19#include <awt_sel_boxes.hxx>
20
21#include <aw_awars.hxx>
22#include <aw_msg.hxx>
23#include <aw_root.hxx>
24
25#include <arb_progress.h>
26#include <arbdbt.h>
27#include <arb_global_defs.h>
28
29// --------------------------------------------------------------------------------
30
31#define AWAR_SQ_PERM "seq_quality/"     // saved in properties
32#define AWAR_SQ_TEMP "tmp/seq_quality/" // not saved in properties
33#define AWAR_SQ_WEIGHT_BASES     AWAR_SQ_PERM "weight_bases"
34#define AWAR_SQ_WEIGHT_DEVIATION AWAR_SQ_PERM "weight_deviation"
35#define AWAR_SQ_WEIGHT_HELIX     AWAR_SQ_PERM "weight_helix"
36#define AWAR_SQ_WEIGHT_CONSENSUS AWAR_SQ_PERM "weight_consensus"
37#define AWAR_SQ_WEIGHT_IUPAC     AWAR_SQ_PERM "weight_iupac"
38#define AWAR_SQ_WEIGHT_GC        AWAR_SQ_PERM "weight_gc"
39
40#define AWAR_SQ_MARK_ONLY_FLAG  AWAR_SQ_PERM "mark_only_flag"
41#define AWAR_SQ_MARK_FLAG  AWAR_SQ_PERM "mark_flag"
42#define AWAR_SQ_MARK_BELOW AWAR_SQ_PERM "mark_below"
43#define AWAR_SQ_REEVALUATE AWAR_SQ_PERM "reevaluate"
44
45#define AWAR_FILTER_PREFIX  AWAR_SQ_TEMP "filter/"
46#define AWAR_FILTER_NAME    AWAR_FILTER_PREFIX "name"
47#define AWAR_FILTER_FILTER  AWAR_FILTER_PREFIX "filter"
48#define AWAR_FILTER_ALI     AWAR_FILTER_PREFIX "alignment"
49
50void SQ_create_awars(AW_root * aw_root, AW_default aw_def) {
51    aw_root->awar_int(AWAR_SQ_WEIGHT_BASES, 5, aw_def);
52    aw_root->awar_int(AWAR_SQ_WEIGHT_DEVIATION, 15, aw_def);
53    aw_root->awar_int(AWAR_SQ_WEIGHT_HELIX, 15, aw_def);
54    aw_root->awar_int(AWAR_SQ_WEIGHT_CONSENSUS, 50, aw_def);
55    aw_root->awar_int(AWAR_SQ_WEIGHT_IUPAC, 5, aw_def);
56    aw_root->awar_int(AWAR_SQ_WEIGHT_GC, 10, aw_def);
57    aw_root->awar_int(AWAR_SQ_MARK_ONLY_FLAG, 0, aw_def);
58    aw_root->awar_int(AWAR_SQ_MARK_FLAG, 1, aw_def);
59    aw_root->awar_int(AWAR_SQ_MARK_BELOW, 40, aw_def);
60    aw_root->awar_int(AWAR_SQ_REEVALUATE, 0, aw_def);
61    aw_root->awar_string(AWAR_FILTER_NAME, "none", aw_def);
62    aw_root->awar_string(AWAR_FILTER_FILTER, "", aw_def);
63    AW_awar *awar_ali = aw_root->awar_string(AWAR_FILTER_ALI, "", aw_def);
64    awar_ali->map("presets/use");
65}
66
67// --------------------------------------------------------------------------------
68
69
70static void sq_calc_seq_quality_cb(AW_window * aww, AW_CL res_from_awt_create_select_filter, AW_CL cl_gb_main) {
71    GBDATA   *gb_main     = (GBDATA*)cl_gb_main;
72    AW_root  *aw_root     = aww->get_root();
73    GB_ERROR  error       = 0;
74    GBT_TREE *tree        = 0;
75    bool      marked_only = (aw_root->awar(AWAR_SQ_MARK_ONLY_FLAG)->read_int() > 0);
76
77    arb_progress main_progress("Calculating sequence quality");
78
79    {
80        char *treename = aw_root->awar(AWAR_TREE)->read_string();
81
82        if (treename && strcmp(treename, NO_TREE_SELECTED) != 0) {
83            error = GB_push_transaction(gb_main);
84
85            if (!error) {
86                tree = GBT_read_tree(gb_main, treename, GBT_TREE_NodeFactory());
87                if (!tree) error = GB_await_error();
88                else {
89                    error = GBT_link_tree(tree, gb_main, false, NULL, NULL);
90                    if (!error) {
91                        GBT_TreeRemoveType mode = marked_only ? GBT_KEEP_MARKED : GBT_REMOVE_ZOMBIES;
92                        tree = GBT_remove_leafs(tree, mode, NULL, NULL, NULL);
93                        if (!tree || tree->is_leaf) {
94                            error = GBS_global_string("Tree contains less than 2 species after removing zombies%s",
95                                                      marked_only ? " and non-marked" : "");
96                        }
97                    }
98                }
99            }
100
101            error = GB_end_transaction(gb_main, error);
102        }
103        free(treename);
104    }
105
106    // if tree == 0 -> do basic quality calculations that are possible without tree information
107    // otherwise    -> use all groups found in tree and compare sequences against the groups they are contained in
108
109    if (!error) {
110        struct SQ_weights weights;
111
112        weights.bases = aw_root->awar(AWAR_SQ_WEIGHT_BASES)->read_int();
113        weights.diff_from_average = aw_root->awar(AWAR_SQ_WEIGHT_DEVIATION)->read_int();
114        weights.helix = aw_root->awar(AWAR_SQ_WEIGHT_HELIX)->read_int();
115        weights.consensus = aw_root->awar(AWAR_SQ_WEIGHT_CONSENSUS)->read_int();
116        weights.iupac = aw_root->awar(AWAR_SQ_WEIGHT_IUPAC)->read_int();
117        weights.gc = aw_root->awar(AWAR_SQ_WEIGHT_GC)->read_int();
118
119        int mark_flag = aw_root->awar(AWAR_SQ_MARK_FLAG)->read_int();
120        int mark_below = aw_root->awar(AWAR_SQ_MARK_BELOW)->read_int();
121        int reevaluate = aw_root->awar(AWAR_SQ_REEVALUATE)->read_int();
122
123        // Load and use Sequence-Filter
124        AP_filter *filter = awt_get_filter((adfiltercbstruct*)res_from_awt_create_select_filter);
125
126        /*
127          SQ_evaluate() generates the final estimation for the quality of an alignment.
128          It takes the values from the different containers, which are generated by the other functions, weights them
129          and calculates a final value. The final value is stored in "value_of_evaluation" (see options).
130          With the values stored in "weights" one can customize how important a value stored in a container becomes
131          for the final result.
132        */
133
134        if (tree == 0) {
135            if (reevaluate) {
136                SQ_mark_species(gb_main, mark_below, marked_only);
137            }
138            else {
139                arb_progress  progress(GBT_get_species_count(gb_main)*2);
140                SQ_GroupData *globalData = new SQ_GroupData_RNA;
141
142                progress.subtitle("pass1");
143                error = SQ_pass1_no_tree(globalData, gb_main, filter, progress);
144                if (!error) {
145                    progress.subtitle("pass2");
146                    error = SQ_pass2_no_tree(globalData, gb_main, filter, progress);
147                    if (!error) {
148                        error = SQ_evaluate(gb_main, weights, marked_only);
149                        if (mark_flag && !error) {
150                            SQ_mark_species(gb_main, mark_below, marked_only);
151                        }
152                    }
153                }
154                if (error) progress.done();
155                delete globalData;
156            }
157        }
158        else {
159            SQ_TREE_ERROR check = SQ_check_tree_structure(tree);
160            if (check != NONE) {
161                switch (check) {
162                    case ZOMBIE:
163                        error = "Found one or more zombies in the tree.\n"
164                            "Please remove them or use another tree before running the quality check tool.";
165                        break;
166                    case MISSING_NODE:
167                        error = "Missing node(s) or unusable tree structure.\n"
168                            "Please fix the tree before running the quality check tool.";
169                        break;
170                    default:
171                        error = "An error occurred while traversing the tree.\n"
172                            "Please fix the tree before running the quality check tool.";
173                        break;
174                }
175            }
176            else if (reevaluate) {
177                SQ_mark_species(gb_main, mark_below, marked_only);
178            }
179            else {
180                arb_progress progress(SQ_count_nodes(tree)*2);
181                SQ_GroupData *globalData = new SQ_GroupData_RNA;
182
183                progress.subtitle("pass1");
184                SQ_calc_and_apply_group_data(tree, gb_main, globalData, filter, progress);
185                progress.subtitle("pass2");
186                SQ_calc_and_apply_group_data2(tree, gb_main, globalData, filter, progress);
187                SQ_evaluate(gb_main, weights, marked_only);
188                if (mark_flag) SQ_mark_species(gb_main, mark_below, marked_only);
189                delete globalData;
190            }
191        }
192        awt_destroy_filter(filter);
193    }
194
195    if (error) aw_message(error);
196
197    SQ_clear_group_dictionary();
198    delete tree;
199}
200
201static void sq_remove_quality_entries_cb(AW_window *, AW_CL cl_gb_main) {
202    GBDATA *gb_main = (GBDATA*)cl_gb_main;
203    SQ_remove_quality_entries(gb_main);
204}
205
206AW_window *SQ_create_seq_quality_window(AW_root *aw_root, GBDATA *gb_main) {
207    // create window for sequence quality calculation (called only once)
208
209    AW_window_simple *aws = new AW_window_simple;
210
211    aws->init(aw_root, "CALC_SEQ_QUALITY", "CALCULATE SEQUENCE QUALITY");
212    aws->load_xfig("seq_quality.fig");
213
214    aws->at("close");
215    aws->callback((AW_CB0) AW_POPDOWN);
216    aws->create_button("CLOSE", "CLOSE", "C");
217
218    aws->at("help");
219    aws->callback(makeHelpCallback("seq_quality.hlp"));
220    aws->create_button("HELP", "HELP", "H");
221
222    aws->at("base");
223    aws->create_input_field(AWAR_SQ_WEIGHT_BASES, 3);
224
225    aws->at("deviation");
226    aws->create_input_field(AWAR_SQ_WEIGHT_DEVIATION, 3);
227
228    aws->at("no_helices");
229    aws->create_input_field(AWAR_SQ_WEIGHT_HELIX, 3);
230
231    aws->at("consensus");
232    aws->create_input_field(AWAR_SQ_WEIGHT_CONSENSUS, 3);
233
234    aws->at("iupac");
235    aws->create_input_field(AWAR_SQ_WEIGHT_IUPAC, 3);
236
237    aws->at("gc_proportion");
238    aws->create_input_field(AWAR_SQ_WEIGHT_GC, 3);
239
240    aws->at("monly");
241    aws->create_toggle(AWAR_SQ_MARK_ONLY_FLAG);
242
243    aws->at("mark");
244    aws->create_toggle(AWAR_SQ_MARK_FLAG);
245
246    aws->at("mark_below");
247    aws->create_input_field(AWAR_SQ_MARK_BELOW, 3);
248
249    aws->at("tree");
250    awt_create_selection_list_on_trees(gb_main, (AW_window *) aws, AWAR_TREE);
251
252    aws->at("filter");
253    adfiltercbstruct *adfilter = awt_create_select_filter(aws->get_root(), gb_main, AWAR_FILTER_NAME);
254    aws->callback(makeCreateWindowCallback(awt_create_select_filter_win, adfilter));
255    aws->create_button("SELECT_FILTER", AWAR_FILTER_NAME);
256
257    aws->at("go");
258    aws->callback(sq_calc_seq_quality_cb, (AW_CL)adfilter, (AW_CL)gb_main);
259    aws->highlight();
260    aws->create_button("GO", "GO", "G");
261
262    aws->at("remove");
263    aws->callback(sq_remove_quality_entries_cb, (AW_CL)gb_main);
264    aws->create_button("Remove", "Remove", "R");
265
266    aws->at("reevaluate");
267    aws->label("Re-Evaluate only");
268    aws->create_toggle(AWAR_SQ_REEVALUATE);
269
270    return aws;
271}
Note: See TracBrowser for help on using the repository browser.