annotate chromeister/src/CHROMEISTER.c @ 0:ee6b15b409e5 draft

Uploaded
author bitlab
date Thu, 13 Dec 2018 06:27:57 -0500
parents
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
1 /*********
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
2
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
3 File CHROMEISTER.c
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
4 Author EPW <estebanpw@uma.es>
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
5 Description Computes hits and generates a dotplot
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
6
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
7 USAGE Usage is described by calling ./CHROMEISTER --help
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
8
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
9
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
10
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
11 **********/
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
12
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
13
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
14 #include <stdio.h>
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
15 #include <stdlib.h>
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
16 #include <math.h>
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
17 #include <string.h>
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
18 #include <ctype.h>
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
19 #include "structs.h"
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
20 #include "alignmentFunctions.h"
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
21 #include "commonFunctions.h"
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
22 #define STARTING_SEQS 1000
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
23 #define PIECE_OF_DB_REALLOC 3200000 //half a gigabyte if divided by 8 bytes
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
24 #define RANGE 2
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
25
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
26 uint64_t custom_kmer = 32; // Defined as external in structs.h
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
27 uint64_t diffuse_z = 4; // Defined as external in structs.h
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
28
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
29 uint64_t get_seq_len(FILE * f);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
30
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
31
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
32 void init_args(int argc, char ** av, FILE ** query, FILE ** database, FILE ** out_database, uint64_t * custom_kmer, uint64_t * dimension, uint64_t * diffuse_z);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
33
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
34 int main(int argc, char ** av){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
35
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
36
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
37 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
38 //Store positions of kmers
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
39 uint64_t n_pools_used = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
40 //Mempool_l * mp = (Mempool_l *) malloc(MAX_MEM_POOLS*sizeof(Mempool_l));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
41 //if(mp == NULL) terror("Could not allocate vectors for memory pools");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
42 Mempool_l mp[MAX_MEM_POOLS];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
43 init_mem_pool_llpos(&mp[n_pools_used]);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
44 //llpos * aux;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
45
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
46 uint64_t n_pools_used_AVL = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
47 Mempool_AVL mp_AVL[MAX_MEM_POOLS];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
48 init_mem_pool_AVL(&mp_AVL[n_pools_used_AVL]);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
49 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
50 Tuple_hits * thit;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
51
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
52 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
53 AVLTree * root = NULL;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
54 root = insert_AVLTree(root, 10, mp_AVL, &n_pools_used_AVL, 0, mp, &n_pools_used);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
55
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
56 llpos * some = find_AVLTree(root, 25);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
57 while(some != NULL){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
58 printf("#%"PRIu64", ", some->pos); some = some->next;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
59 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
60 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
61
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
62 uint64_t i, j;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
63
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
64 //query to read kmers from, database to find seeds
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
65 FILE * query = NULL, * database = NULL, * out_database = NULL;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
66 uint64_t dimension = 1000; // Default 1000 * 1000
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
67
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
68
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
69 init_args(argc, av, &query, &database, &out_database, &custom_kmer, &dimension, &diffuse_z);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
70
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
71
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
72
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
73 unsigned char char_converter[91];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
74 char_converter[(unsigned char)'A'] = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
75 char_converter[(unsigned char)'C'] = 1;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
76 char_converter[(unsigned char)'G'] = 2;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
77 char_converter[(unsigned char)'T'] = 3;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
78
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
79
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
80 // Variables to account for positions
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
81 // Print info
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
82 fprintf(stdout, "[INFO] Loading database\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
83 // Variables to read kmers
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
84 char c = 'N'; //Char to read character
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
85 // Current length of array and variables for the buffer
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
86 uint64_t idx = 0, r = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
87
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
88 //Vector to read in batches
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
89 char * temp_seq_buffer = NULL;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
90 if ((temp_seq_buffer = calloc(READBUF, sizeof(char))) == NULL) {
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
91 terror("Could not allocate memory for read buffer");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
92 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
93
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
94 //Dimensional matrix
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
95 uint64_t ** representation = (uint64_t **) calloc(dimension+1, sizeof(uint64_t *));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
96 if(representation == NULL) terror("Could not allocate representation");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
97 for(i=0; i<dimension+1; i++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
98 representation[i] = (uint64_t *) calloc(dimension+1, sizeof(uint64_t));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
99 if(representation[i] == NULL) terror("Could not allocate second loop representation");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
100 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
101
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
102 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
103 fseek(database, 0, SEEK_END);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
104 uint64_t aprox_len_query = ftell(database);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
105 uint64_t aprox_len_db = aprox_len_query;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
106 rewind(database);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
107 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
108 uint64_t aprox_len_query = get_seq_len(database);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
109 uint64_t aprox_len_db = aprox_len_query;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
110
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
111 uint64_t a_hundreth = (aprox_len_query/100);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
112
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
113 unsigned char curr_kmer[custom_kmer], reverse_kmer[custom_kmer];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
114 curr_kmer[0] = reverse_kmer[0] = '\0';
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
115 uint64_t word_size = 0, word_size_rev = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
116
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
117 //To hold all information related to database
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
118 uint64_t current_len = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
119
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
120 //To force reading from the buffer
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
121 idx = READBUF + 1;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
122
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
123 //unsigned char aux_kmer[custom_kmer+1];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
124
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
125 //Vector to store query seq
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
126 unsigned char * seq_vector_query = (unsigned char *) malloc(READBUF*sizeof(unsigned char));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
127 if(seq_vector_query == NULL) terror("Could not allocate memory for query vector");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
128
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
129 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
130 Container * ct = (Container *) calloc(1, sizeof(Container));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
131 if(ct == NULL) terror("Could not allocate container");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
132 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
133
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
134
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
135
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
136 Index * ctidx = (Index *) calloc(1, sizeof(Index));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
137 if(ctidx == NULL) terror("Could not allocate container");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
138
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
139
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
140 //begin = clock();
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
141
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
142
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
143 c = buffered_fgetc(temp_seq_buffer, &idx, &r, database);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
144 while((!feof(database) || (feof(database) && idx < r))){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
145
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
146 if(c == '>'){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
147
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
148
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
149
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
150 while(c != '\n') c = buffered_fgetc(temp_seq_buffer, &idx, &r, database); //Skip ID
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
151
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
152
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
153 while(c != '>' && (!feof(database) || (feof(database) && idx < r))){ //Until next id
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
154 c = buffered_fgetc(temp_seq_buffer, &idx, &r, database);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
155 c = toupper(c);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
156 if(c == 'A' || c == 'C' || c == 'G' || c == 'T'){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
157 curr_kmer[word_size] = (unsigned char) c;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
158 if(word_size < custom_kmer) ++word_size;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
159 ++current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
160 if(current_len % a_hundreth == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
161 fprintf(stdout, "\r%"PRIu64"%%...", 1+100*current_len/aprox_len_query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
162 //printf("%"PRIu64"%%..wasted: (%e) (%e)", 1+100*pos_in_query/aprox_len_query, (double)(wasted_cycles_forward)/CLOCKS_PER_SEC, (double)(wasted_cycles_reverse)/CLOCKS_PER_SEC);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
163 fflush(stdout);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
164 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
165
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
166
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
167
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
168 }else{ //It can be anything (including N, Y, X ...)
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
169
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
170 if(c != '\n' && c != '>'){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
171 word_size = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
172 // data_database.sequences[pos_in_database++] = (unsigned char) 'N'; //Convert to N
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
173 ++current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
174
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
175 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
176 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
177 //if(current_len % 1000000 == 0) printf(" curr len %" PRIu64"\n", current_len);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
178 if(word_size == custom_kmer){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
179 //write to hash table
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
180
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
181
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
182 thit = &ctidx->table[char_converter[curr_kmer[0]]][char_converter[curr_kmer[1]]][char_converter[curr_kmer[2]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
183 [char_converter[curr_kmer[3]]][char_converter[curr_kmer[4]]][char_converter[curr_kmer[5]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
184 [char_converter[curr_kmer[6]]][char_converter[curr_kmer[7]]][char_converter[curr_kmer[8]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
185 [char_converter[curr_kmer[9]]][char_converter[curr_kmer[10]]][char_converter[curr_kmer[11]]];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
186
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
187 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
188 typedef struct tuple_hits{
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
189 int repetition;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
190 int hit_count;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
191 uint64_t key;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
192 uint64_t pos;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
193 } Tuple_hits;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
194 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
195
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
196 if(thit->repetition == FALSE){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
197 // Then we can insert
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
198 thit->hit_count = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
199 thit->key = collisioned_hash(&curr_kmer[0], custom_kmer);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
200 thit->pos = current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
201 }else{
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
202 // Otherwise we break it
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
203 thit->repetition = TRUE;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
204 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
205
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
206 //thit->root = insert_AVLTree(thit->root, hashOfWord(&curr_kmer[0], custom_kmer, FIXED_K), mp_AVL, &n_pools_used_AVL, current_len, mp, &n_pools_used);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
207 //thit->root = insert_AVLTree(thit->root, collisioned_hash(&curr_kmer[0], custom_kmer), mp_AVL, &n_pools_used_AVL, current_len, mp, &n_pools_used);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
208
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
209
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
210
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
211 // Non overlapping
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
212 word_size = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
213
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
214
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
215 // Overlapping
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
216 //memmove(&curr_kmer[0], &curr_kmer[1], custom_kmer-1);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
217 //--word_size;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
218 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
219 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
220 word_size = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
221
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
222 }else{
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
223 c = buffered_fgetc(temp_seq_buffer, &idx, &r, database);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
224 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
225
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
226 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
227
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
228
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
229 //end = clock();
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
230
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
231 // data_database.total_len = pos_in_database;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
232
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
233 //fprintf(stdout, "[INFO] Database loaded and of length %"PRIu64". Hash table building took %e seconds\n", data_database.total_len, (double)(end-begin)/CLOCKS_PER_SEC);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
234 fprintf(stdout, "[INFO] Database loaded and of length %"PRIu64".\n", current_len);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
235 //close database
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
236 fclose(database);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
237
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
238
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
239
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
240 //begin = clock();
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
241
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
242
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
243
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
244
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
245
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
246 double pixel_size_db = (double) dimension / (double) current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
247 double ratio_db = (double) current_len / dimension;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
248
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
249
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
250 // Get file length
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
251
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
252 //fseek(query, 0, SEEK_END);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
253 //aprox_len_query = ftell(query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
254 //rewind(query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
255 aprox_len_query = get_seq_len(query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
256
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
257 //uint64_t reallocs_hash_holder_table = 1;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
258 //uint64_t n_items_hash_holder_table = aprox_len_query / 5;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
259
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
260 //Hash_holder * hash_holder_table = (Hash_holder *) calloc(n_items_hash_holder_table, sizeof(Hash_holder));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
261 //if(hash_holder_table == NULL) terror("Could not allocate hash holding table");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
262
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
263 a_hundreth = (aprox_len_query/100);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
264 double pixel_size_query = (double) dimension / (double) aprox_len_query;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
265 double ratio_query = (double) aprox_len_query / dimension;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
266
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
267
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
268 double i_r_fix = MAX(1.0, custom_kmer * pixel_size_query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
269 double j_r_fix = MAX(1.0, custom_kmer * pixel_size_db);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
270
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
271
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
272
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
273 fprintf(stdout, "[INFO] Ratios: Q [%e] D [%e]. Lenghts: Q [%"PRIu64"] D [%"PRIu64"]\n", ratio_query, ratio_db, aprox_len_query, current_len);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
274 fprintf(stdout, "[INFO] Pixel size: Q [%e] D [%e].\n", pixel_size_query, pixel_size_db);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
275
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
276
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
277 fprintf(stdout, "[INFO] Computing absolute hit numbers.\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
278
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
279
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
280 current_len = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
281
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
282 //llpos * the_original_hit;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
283
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
284 //To force reading from the buffer
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
285 idx = READBUF + 1;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
286 c = buffered_fgetc(temp_seq_buffer, &idx, &r, query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
287 //uint64_t c_hash_holder = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
288
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
289 while((!feof(query) || (feof(query) && idx < r))){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
290
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
291 if(c == '>'){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
292 word_size = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
293 word_size_rev = custom_kmer-1;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
294
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
295
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
296
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
297
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
298 while(c != '\n'){ c = buffered_fgetc(temp_seq_buffer, &idx, &r, query); } //Skip ID
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
299
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
300
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
301 while(c != '>' && (!feof(query) || (feof(query) && idx < r))){ //Until next id
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
302 c = buffered_fgetc(temp_seq_buffer, &idx, &r, query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
303 c = toupper(c);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
304 if(c == 'A' || c == 'C' || c == 'G' || c == 'T'){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
305
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
306 ++current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
307 if(current_len % a_hundreth == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
308 fprintf(stdout, "\r%"PRIu64"%%...", 1+100*current_len/aprox_len_query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
309 fflush(stdout);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
310 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
311 curr_kmer[word_size] = (unsigned char) c;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
312 ++word_size;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
313
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
314 switch(c){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
315 case ('A'): reverse_kmer[word_size_rev] = (unsigned)'T';
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
316 break;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
317 case ('C'): reverse_kmer[word_size_rev] = (unsigned)'G';
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
318 break;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
319 case ('G'): reverse_kmer[word_size_rev] = (unsigned)'C';
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
320 break;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
321 case ('T'): reverse_kmer[word_size_rev] = (unsigned)'A';
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
322 break;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
323 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
324 if(word_size_rev != 0) --word_size_rev;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
325
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
326
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
327
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
328
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
329 if(word_size == custom_kmer){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
330
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
331
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
332 //hash_forward = hashOfWord(&curr_kmer[0], custom_kmer, FIXED_K);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
333 //hash_reverse = hashOfWord(&reverse_kmer[0], custom_kmer, FIXED_K);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
334 uint64_t hash_forward, hash_reverse;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
335 hash_forward = collisioned_hash(&curr_kmer[0], custom_kmer);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
336 hash_reverse = collisioned_hash(&reverse_kmer[0], custom_kmer);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
337
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
338
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
339 thit = &ctidx->table[char_converter[curr_kmer[0]]][char_converter[curr_kmer[1]]][char_converter[curr_kmer[2]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
340 [char_converter[curr_kmer[3]]][char_converter[curr_kmer[4]]][char_converter[curr_kmer[5]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
341 [char_converter[curr_kmer[6]]][char_converter[curr_kmer[7]]][char_converter[curr_kmer[8]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
342 [char_converter[curr_kmer[9]]][char_converter[curr_kmer[10]]][char_converter[curr_kmer[11]]];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
343
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
344 //AVLTree * search = find_AVLTree(thit->root, hash_forward);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
345
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
346 if(thit->repetition == FALSE && hash_forward == thit->key){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
347 // Attention ::::: you were not removing the ones with count==1 earlier
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
348 thit->pos_in_y = current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
349 thit->hit_count++;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
350 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
351
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
352 thit = &ctidx->table[char_converter[reverse_kmer[0]]][char_converter[reverse_kmer[1]]][char_converter[reverse_kmer[2]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
353 [char_converter[reverse_kmer[3]]][char_converter[reverse_kmer[4]]][char_converter[reverse_kmer[5]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
354 [char_converter[reverse_kmer[6]]][char_converter[reverse_kmer[7]]][char_converter[reverse_kmer[8]]]
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
355 [char_converter[reverse_kmer[9]]][char_converter[reverse_kmer[10]]][char_converter[reverse_kmer[11]]];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
356
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
357 if(thit->repetition == FALSE && hash_reverse == thit->key){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
358 // Attention ::::: you were not removing the ones with count==1 earlier
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
359 thit->pos_in_y = current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
360 thit->hit_count++;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
361 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
362
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
363 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
364 if(search != NULL && search->count == 1){ //If count is two, then it is a rep
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
365 thit->hit_count += search->count;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
366
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
367 hash_holder_table[c_hash_holder].pos = current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
368 hash_holder_table[c_hash_holder].node = search;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
369 hash_holder_table[c_hash_holder].th = thit;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
370 ++c_hash_holder;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
371 if(c_hash_holder == n_items_hash_holder_table*reallocs_hash_holder_table){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
372 ++reallocs_hash_holder_table;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
373 hash_holder_table = (Hash_holder *) realloc(hash_holder_table, n_items_hash_holder_table*reallocs_hash_holder_table*sizeof(Hash_holder));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
374 if(hash_holder_table == NULL) terror("Could not realloc hash holder table");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
375 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
376 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
377 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
378
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
379
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
380
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
381
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
382
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
383 //search = find_AVLTree(thit->root, hash_reverse);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
384 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
385 if(search != NULL && search->count == 1){ //If count is two, then it is a rep
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
386
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
387 thit->hit_count += search->count;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
388 hash_holder_table[c_hash_holder].pos = current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
389 hash_holder_table[c_hash_holder].node = search;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
390 hash_holder_table[c_hash_holder].th = thit;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
391 ++c_hash_holder;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
392 if(c_hash_holder == n_items_hash_holder_table*reallocs_hash_holder_table){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
393 ++reallocs_hash_holder_table;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
394 hash_holder_table = (Hash_holder *) realloc(hash_holder_table, n_items_hash_holder_table*reallocs_hash_holder_table*sizeof(Hash_holder));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
395 if(hash_holder_table == NULL) terror("Could not realloc hash holder table");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
396 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
397 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
398 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
399
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
400 // Overlapping
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
401
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
402 memmove(&curr_kmer[0], &curr_kmer[1], custom_kmer-1);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
403 memmove(&reverse_kmer[1], &reverse_kmer[0], custom_kmer-1);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
404 --word_size;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
405
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
406 // Non overlapping
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
407 //word_size = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
408 //word_size_rev = custom_kmer-1;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
409 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
410 }else{
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
411 if(c != '\n' && c != '>'){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
412 word_size = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
413 word_size_rev = custom_kmer-1;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
414 ++current_len;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
415 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
416 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
417 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
418 }else{
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
419 c = buffered_fgetc(temp_seq_buffer, &idx, &r, query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
420 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
421
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
422 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
423
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
424 /// Out
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
425
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
426 fprintf(stdout, "Scanning hits table.\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
427
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
428 a_hundreth = MAX(1, TOTAL_ENTRIES/100);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
429 uint64_t t_computed = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
430 uint64_t w0,w1,w2,w3,w4,w5,w6,w7,w8,w9,w10,w11;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
431 for(w0=0;w0<4;w0++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
432 for(w1=0;w1<4;w1++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
433 for(w2=0;w2<4;w2++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
434 for(w3=0;w3<4;w3++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
435 for(w4=0;w4<4;w4++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
436 for(w5=0;w5<4;w5++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
437 for(w6=0;w6<4;w6++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
438 for(w7=0;w7<4;w7++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
439 for(w8=0;w8<4;w8++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
440 for(w9=0;w9<4;w9++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
441 for(w10=0;w10<4;w10++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
442 for(w11=0;w11<4;w11++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
443
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
444 if(t_computed % a_hundreth == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
445 fprintf(stdout, "\r%"PRIu64"%%...", 1+100*t_computed/TOTAL_ENTRIES);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
446 fflush(stdout);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
447 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
448 ++t_computed;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
449 Tuple_hits * taux = &ctidx->table[w0][w1][w2][w3][w4][w5][w6][w7][w8][w9][w10][w11];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
450 if(taux->hit_count == 1){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
451 // We plot it
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
452 // Convert scale to representation
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
453 uint64_t redir_db = (uint64_t) (taux->pos / (ratio_db));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
454 uint64_t redir_query = (uint64_t) (taux->pos_in_y / (ratio_query));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
455 double i_r = i_r_fix; double j_r = j_r_fix;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
456 while((uint64_t) i_r >= 1 && (uint64_t) j_r >= 1){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
457 if((int64_t) redir_query - (int64_t) i_r > 0 && (int64_t) redir_db - (int64_t) j_r > 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
458 representation[(int64_t) redir_query - (int64_t) i_r][(int64_t) redir_db - (int64_t) j_r]++;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
459 }else{
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
460 representation[redir_query][redir_db]++;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
461 break;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
462 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
463 i_r -= MIN(1.0, pixel_size_query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
464 j_r -= MIN(1.0, pixel_size_db);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
465 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
466 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
467 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
468 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
469 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
470 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
471 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
472 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
473 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
474 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
475 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
476 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
477 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
478 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
479
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
480
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
481 //double average_hit = ((double) total_hits / (double) table_size);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
482 //average_hit = 2.2;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
483
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
484 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
485 //fprintf(stdout, "[INFO] Total hit count is %"PRIu64" on a size of %"PRIu64" Avg = %e.\n", total_hits, table_size, average_hit);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
486 fprintf(stdout, "[INFO] Total hit count is %"PRIu64" on a size of %"PRIu64" E' = %e.\n", total_hits, table_size, Eprime);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
487
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
488
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
489
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
490
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
491
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
492 a_hundreth = MAX(1,c_hash_holder/100);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
493
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
494 for(current_len = 0; current_len < c_hash_holder; current_len++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
495
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
496 if(current_len % a_hundreth == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
497 fprintf(stdout, "\r%"PRIu64"%%...", 1+100*current_len/c_hash_holder);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
498 fflush(stdout);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
499 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
500
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
501 aux = hash_holder_table[current_len].node->next;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
502
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
503 //if(hash_holder_table[current_len].th->hit_count < (uint64_t) average_hit){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
504 if(hash_holder_table[current_len].th->hit_count < (uint64_t) Eprime){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
505 while(aux != NULL){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
506 // Convert scale to representation
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
507 uint64_t redir_db = (uint64_t) (aux->pos / (ratio_db));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
508 uint64_t redir_query = (uint64_t) (hash_holder_table[current_len].pos / (ratio_query));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
509 double i_r = i_r_fix; double j_r = j_r_fix;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
510 while((uint64_t) i_r >= 1 && (uint64_t) j_r >= 1){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
511 if((int64_t) redir_query - (int64_t) i_r > 0 && (int64_t) redir_db - (int64_t) j_r > 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
512 representation[(int64_t) redir_query - (int64_t) i_r][(int64_t) redir_db - (int64_t) j_r]++;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
513 }else{
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
514 representation[redir_query][redir_db]++;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
515 break;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
516 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
517 i_r -= MIN(1.0, pixel_size_query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
518 j_r -= MIN(1.0, pixel_size_db);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
519 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
520 aux = aux->next;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
521 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
522 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
523 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
524 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
525
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
526
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
527 //end = clock();
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
528
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
529
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
530
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
531
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
532 //fprintf(stdout, "\n[INFO] Query length %"PRIu64". Hits completed. Took %e seconds\n", data_query.total_len, (double)(end-begin)/CLOCKS_PER_SEC);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
533 fprintf(stdout, "\n[INFO] Query length %"PRIu64".\n", current_len);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
534
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
535 //begin = clock();
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
536
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
537 //reads_per_thread = (uint64_t) (floorl((long double) data_query.n_seqs / (long double) n_threads));
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
538
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
539 fprintf(stdout, "[INFO] Writing matrix.\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
540
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
541
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
542 uint64_t unique_diffuse = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
543 fprintf(out_database, "%"PRIu64"\n", aprox_len_query);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
544 fprintf(out_database, "%"PRIu64"\n", aprox_len_db);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
545 // And replace 2's with 1's
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
546
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
547 for(i=0; i<dimension+1; i++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
548 for(j=0; j<dimension; j++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
549 fprintf(out_database, "%"PRIu64" ", representation[i][j]);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
550 unique_diffuse += representation[i][j];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
551 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
552 fprintf(out_database, "%"PRIu64"\n", representation[i][dimension]);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
553 unique_diffuse += representation[i][dimension];
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
554 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
555
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
556 fprintf(stdout, "[INFO] Found %"PRIu64" unique hits for z = %"PRIu64".\n", unique_diffuse, diffuse_z);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
557
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
558
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
559
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
560 //free(ct->table);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
561 //free(hash_holder_table);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
562 /*
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
563 for(i=0;i<=n_pools_used_AVL;i++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
564 free(mp_AVL[i].base);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
565 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
566
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
567 for(i=0;i<=n_pools_used;i++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
568 free(mp[i].base);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
569 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
570 */
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
571 for(i=0;i<dimension;i++){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
572 free(representation[i]);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
573 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
574 free(representation);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
575 if(out_database != NULL) fclose(out_database);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
576
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
577 return 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
578 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
579
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
580 void init_args(int argc, char ** av, FILE ** query, FILE ** database, FILE ** out_database, uint64_t * custom_kmer, uint64_t * dimension, uint64_t * diffuse_z){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
581
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
582 int pNum = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
583 while(pNum < argc){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
584 if(strcmp(av[pNum], "--help") == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
585 fprintf(stdout, "USAGE:\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
586 fprintf(stdout, " CHROMEISTER -query [query] -db [database] -out [outfile]\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
587 fprintf(stdout, "OPTIONAL:\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
588 fprintf(stdout, " -kmer [Integer: k>1 (default 32)]\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
589 fprintf(stdout, " -diffuse [Integer: z>0 (default 4)]\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
590 fprintf(stdout, " -dimension Size of the output [Integer: d>0 (default 1000)]\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
591 fprintf(stdout, " -out [File path]\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
592 fprintf(stdout, " --help Shows help for program usage\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
593 fprintf(stdout, "\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
594 fprintf(stdout, "PLEASE NOTICE: The reverse complementary is calculated for the QUERY.\n");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
595 exit(1);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
596 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
597 if(strcmp(av[pNum], "-query") == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
598 *query = fopen64(av[pNum+1], "rt");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
599 if(query==NULL) terror("Could not open query file");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
600 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
601 if(strcmp(av[pNum], "-db") == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
602 *database = fopen64(av[pNum+1], "rt");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
603 if(database==NULL) terror("Could not open database file");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
604 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
605 if(strcmp(av[pNum], "-out") == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
606 *out_database = fopen(av[pNum+1], "wt");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
607 if(out_database==NULL) terror("Could not open output database file");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
608 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
609 if(strcmp(av[pNum], "-kmer") == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
610 *custom_kmer = (uint64_t) atoi(av[pNum+1]);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
611 if(*custom_kmer < BYTES_IN_MER) terror("K-mer size must be larger than 4");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
612 if(*custom_kmer % BYTES_IN_MER != 0) terror("K-mer size must be a multiple of 4");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
613
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
614 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
615 if(strcmp(av[pNum], "-diffuse") == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
616 *diffuse_z = (uint64_t) atoi(av[pNum+1]);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
617 if(*diffuse_z == 0 || *diffuse_z > 32) terror("Z must satisfy 0<z<=32");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
618
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
619 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
620
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
621 if(strcmp(av[pNum], "-dimension") == 0){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
622 *dimension = (uint64_t) atoi(av[pNum+1]);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
623 if(*dimension < 1) terror("Dimension must be a positive integer");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
624 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
625
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
626 pNum++;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
627 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
628
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
629 if(*query==NULL || *database==NULL || *out_database==NULL) terror("A query, database and output file is required");
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
630 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
631
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
632 uint64_t get_seq_len(FILE * f) {
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
633 char c = '\0';
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
634 uint64_t l = 0;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
635
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
636 while(!feof(f)){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
637 c = getc(f);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
638
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
639 if(c == '>'){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
640 while(c != '\n') c = getc(f);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
641 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
642 c = toupper(c);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
643 if(c >= 'A' && c <= 'Z'){
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
644 ++l;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
645 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
646 }
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
647
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
648
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
649 rewind(f);
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
650 return l;
ee6b15b409e5 Uploaded
bitlab
parents:
diff changeset
651 }