1 #ifdef _cplusplus
2 extern "C" {
3 #endif
4 #include "estwise3.h"
5
6 # line 5 "estwise3.c"
7
8
9 /***************** C functions ****************/
10 /* Written using dynamite */
11 /* Sat Sep 8 09:05:31 2007 */
12 /* email birney@sanger.ac.uk */
13 /* http://www.sanger.ac.uk/Users/birney/dynamite */
14 /*************************************************/
15
16
17 /* Please report any problems or bugs to */
18 /* Ewan Birney, birney@sanger.ac.uk */
19
20
21 /* basic set of macros to map states to numbers */
22 #define MATCH 0
23 #define INSERT 1
24 #define DELETE 2
25
26
27 #define START 0
28 #define END 1
29
30
31 #define EstWise3_EXPL_MATRIX(this_matrix,i,j,STATE) this_matrix->basematrix->matrix[((j+5)*3)+STATE][i+1]
32 #define EstWise3_EXPL_SPECIAL(matrix,i,j,STATE) matrix->basematrix->specmatrix[STATE][j+5]
33 #define EstWise3_READ_OFF_ERROR -7
34
35
36
37 #define EstWise3_VSMALL_MATRIX(mat,i,j,STATE) mat->basematrix->matrix[(j+6)%6][((i+1)*3)+STATE]
38 #define EstWise3_VSMALL_SPECIAL(mat,i,j,STATE) mat->basematrix->specmatrix[(j+6)%6][STATE]
39
40
41
42
43 #define EstWise3_SHATTER_SPECIAL(matrix,i,j,STATE) matrix->shatter->special[STATE][j]
44 #define EstWise3_SHATTER_MATRIX(matrix,i,j,STATE) fetch_cell_value_ShatterMatrix(mat->shatter,i,j,STATE)
45
46
47 /* Function: PackAln_read_Shatter_EstWise3(mat)
48 *
49 * Descrip: Reads off PackAln from shatter matrix structure
50 *
51 *
52 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
53 *
54 * Return [UNKN ] Undocumented return value [PackAln *]
55 *
56 */
PackAln_read_Shatter_EstWise3(EstWise3 * mat)57 PackAln * PackAln_read_Shatter_EstWise3(EstWise3 * mat)
58 {
59 EstWise3_access_func_holder holder;
60
61
62 holder.access_main = EstWise3_shatter_access_main;
63 holder.access_special = EstWise3_shatter_access_special;
64 assert(mat);
65 assert(mat->shatter);
66 return PackAln_read_generic_EstWise3(mat,holder);
67 }
68
69
70 /* Function: EstWise3_shatter_access_main(mat,i,j,state)
71 *
72 * Descrip: No Description
73 *
74 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
75 * Arg: i [UNKN ] Undocumented argument [int]
76 * Arg: j [UNKN ] Undocumented argument [int]
77 * Arg: state [UNKN ] Undocumented argument [int]
78 *
79 * Return [UNKN ] Undocumented return value [int]
80 *
81 */
EstWise3_shatter_access_main(EstWise3 * mat,int i,int j,int state)82 int EstWise3_shatter_access_main(EstWise3 * mat,int i,int j,int state)
83 {
84 return EstWise3_SHATTER_MATRIX(mat,i,j,state);
85 }
86
87
88 /* Function: EstWise3_shatter_access_special(mat,i,j,state)
89 *
90 * Descrip: No Description
91 *
92 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
93 * Arg: i [UNKN ] Undocumented argument [int]
94 * Arg: j [UNKN ] Undocumented argument [int]
95 * Arg: state [UNKN ] Undocumented argument [int]
96 *
97 * Return [UNKN ] Undocumented return value [int]
98 *
99 */
EstWise3_shatter_access_special(EstWise3 * mat,int i,int j,int state)100 int EstWise3_shatter_access_special(EstWise3 * mat,int i,int j,int state)
101 {
102 return EstWise3_SHATTER_SPECIAL(mat,i,j,state);
103 }
104
105
106 /* Function: calculate_shatter_EstWise3(mat,dpenv)
107 *
108 * Descrip: This function calculates the EstWise3 matrix when in shatter mode
109 *
110 *
111 * Arg: mat [UNKN ] (null) [EstWise3 *]
112 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
113 *
114 * Return [UNKN ] Undocumented return value [boolean]
115 *
116 */
calculate_shatter_EstWise3(EstWise3 * mat,DPEnvelope * dpenv)117 boolean calculate_shatter_EstWise3(EstWise3 * mat,DPEnvelope * dpenv)
118 {
119 int i;
120 int j;
121 int k;
122 int should_calc;
123 int leni;
124 int lenj;
125 int tot;
126 int num;
127 int starti;
128 int startj;
129 int endi;
130 int endj;
131
132
133 int * SIG_0_0;
134 int * SIG_1_3;
135 int * SIG_1_2;
136 int * SIG_1_1;
137 int * SIG_1_4;
138 int * SIG_1_5;
139 int * SIG_0_3;
140 int * SIG_0_2;
141 int * SIG_0_1;
142 int * SIG_0_4;
143 int * SIG_0_5;
144 int * SIG_1_0;
145
146
147 leni = mat->leni;
148 lenj = mat->lenj;
149
150
151 mat->shatter = new_ShatterMatrix(dpenv,3,lenj,2);
152 prepare_DPEnvelope(dpenv);
153 starti = dpenv->starti;
154 if( starti < 0 )
155 starti = 0;
156 startj = dpenv->startj;
157 if( startj < 0 )
158 startj = 0;
159 endi = dpenv->endi;
160 if( endi > mat->leni )
161 endi = mat->leni;
162 endj = dpenv->endj;
163 if( endj > mat->lenj )
164 endj = mat->lenj;
165 tot = (endi-starti) * (endj-startj);
166 num = 0;
167
168
169 start_reporting("EstWise3 Matrix calculation: ");
170 for(j=startj;j<endj;j++) {
171 auto int score;
172 auto int temp;
173 for(i=starti;i<endi;i++) {
174 /* Check if is in envelope - code identical to is_in_DPEnvelope, but aggressively inlined here for speed */
175 should_calc = 0;
176 for(k=0;k<dpenv->len;k++) {
177 auto DPUnit * u;
178 u = dpenv->dpu[k];
179 switch(u->type) {
180 case DPENV_RECT :
181 if( i >= u->starti && j >= u->startj && i < (u->starti+u->height) && j < (u->startj+u->length))
182 should_calc = 1;
183 break;
184 case DPENV_DIAG :
185 if( abs( (i-j) - (u->starti-u->startj)) <= u->height && i+j >= u->starti+u->startj && i+j+u->length >= u->starti+u->startj)
186 should_calc = 1;
187 break;
188 }
189 if( should_calc == 1 )
190 break;
191 }
192 if( should_calc == 0)
193 continue;
194
195
196 SIG_0_0 = fetch_cell_from_ShatterMatrix(mat->shatter,i,j);
197 SIG_1_3 = fetch_cell_from_ShatterMatrix(mat->shatter,i-1,j-3);
198 SIG_1_2 = fetch_cell_from_ShatterMatrix(mat->shatter,i-1,j-2);
199 SIG_1_1 = fetch_cell_from_ShatterMatrix(mat->shatter,i-1,j-1);
200 SIG_1_4 = fetch_cell_from_ShatterMatrix(mat->shatter,i-1,j-4);
201 SIG_1_5 = fetch_cell_from_ShatterMatrix(mat->shatter,i-1,j-5);
202 SIG_0_3 = fetch_cell_from_ShatterMatrix(mat->shatter,i-0,j-3);
203 SIG_0_2 = fetch_cell_from_ShatterMatrix(mat->shatter,i-0,j-2);
204 SIG_0_1 = fetch_cell_from_ShatterMatrix(mat->shatter,i-0,j-1);
205 SIG_0_4 = fetch_cell_from_ShatterMatrix(mat->shatter,i-0,j-4);
206 SIG_0_5 = fetch_cell_from_ShatterMatrix(mat->shatter,i-0,j-5);
207 SIG_1_0 = fetch_cell_from_ShatterMatrix(mat->shatter,i-1,j-0);
208
209
210
211
212 /* For state MATCH */
213 /* setting first movement to score */
214 score = SIG_1_3[MATCH] + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
215 /* From state INSERT to state MATCH */
216 temp = SIG_1_3[INSERT] + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
217 if( temp > score ) {
218 score = temp;
219 }
220 /* From state DELETE to state MATCH */
221 temp = SIG_1_3[DELETE] + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
222 if( temp > score ) {
223 score = temp;
224 }
225 /* From state START to state MATCH */
226 temp = EstWise3_SHATTER_SPECIAL(mat,i-1,j-3,START) + (mat->query->seg[i]->transition[GW_START2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
227 if( temp > score ) {
228 score = temp;
229 }
230 /* From state MATCH to state MATCH */
231 temp = SIG_1_2[MATCH] + mat->cp->trans[PCD_DELETE_1_BASE];
232 if( temp > score ) {
233 score = temp;
234 }
235 /* From state MATCH to state MATCH */
236 temp = SIG_1_1[MATCH] + mat->cp->trans[PCD_DELETE_2_BASE];
237 if( temp > score ) {
238 score = temp;
239 }
240 /* From state MATCH to state MATCH */
241 temp = SIG_1_4[MATCH] + mat->cp->trans[PCD_INSERT_1_BASE];
242 if( temp > score ) {
243 score = temp;
244 }
245 /* From state MATCH to state MATCH */
246 temp = SIG_1_5[MATCH] + mat->cp->trans[PCD_INSERT_2_BASE];
247 if( temp > score ) {
248 score = temp;
249 }
250 /* From state INSERT to state MATCH */
251 temp = SIG_1_2[INSERT] + mat->cp->trans[PCD_DELETE_1_BASE];
252 if( temp > score ) {
253 score = temp;
254 }
255 /* From state INSERT to state MATCH */
256 temp = SIG_1_1[INSERT] + mat->cp->trans[PCD_DELETE_2_BASE];
257 if( temp > score ) {
258 score = temp;
259 }
260 /* From state INSERT to state MATCH */
261 temp = SIG_1_4[INSERT] + mat->cp->trans[PCD_INSERT_1_BASE];
262 if( temp > score ) {
263 score = temp;
264 }
265 /* From state INSERT to state MATCH */
266 temp = SIG_1_5[INSERT] + mat->cp->trans[PCD_INSERT_2_BASE];
267 if( temp > score ) {
268 score = temp;
269 }
270 /* From state DELETE to state MATCH */
271 temp = SIG_1_2[DELETE] + mat->cp->trans[PCD_DELETE_1_BASE];
272 if( temp > score ) {
273 score = temp;
274 }
275 /* From state DELETE to state MATCH */
276 temp = SIG_1_1[DELETE] + mat->cp->trans[PCD_DELETE_2_BASE];
277 if( temp > score ) {
278 score = temp;
279 }
280 /* From state DELETE to state MATCH */
281 temp = SIG_1_4[DELETE] + mat->cp->trans[PCD_INSERT_1_BASE];
282 if( temp > score ) {
283 score = temp;
284 }
285 /* From state DELETE to state MATCH */
286 temp = SIG_1_5[DELETE] + mat->cp->trans[PCD_INSERT_2_BASE];
287 if( temp > score ) {
288 score = temp;
289 }
290
291
292 /* Ok - finished max calculation for MATCH */
293 /* Add any movement independant score and put away */
294 SIG_0_0[MATCH] = score;
295
296
297 /* state MATCH is a source for special END */
298 temp = score + (mat->query->seg[i]->transition[GW_MATCH2END]) + (0) ;
299 if( temp > EstWise3_SHATTER_SPECIAL(mat,i,j,END) ) {
300 EstWise3_SHATTER_SPECIAL(mat,i,j,END) = temp;
301 }
302
303
304
305
306 /* Finished calculating state MATCH */
307
308
309 /* For state INSERT */
310 /* setting first movement to score */
311 score = SIG_0_3[MATCH] + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
312 /* From state INSERT to state INSERT */
313 temp = SIG_0_3[INSERT] + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
314 if( temp > score ) {
315 score = temp;
316 }
317 /* From state DELETE to state INSERT */
318 temp = SIG_0_3[DELETE] + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
319 if( temp > score ) {
320 score = temp;
321 }
322 /* From state START to state INSERT */
323 temp = EstWise3_SHATTER_SPECIAL(mat,i-0,j-3,START) + (mat->query->seg[i]->transition[GW_START2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
324 if( temp > score ) {
325 score = temp;
326 }
327 /* From state INSERT to state INSERT */
328 temp = SIG_0_2[INSERT] + mat->cp->trans[PCD_DELETE_1_BASE];
329 if( temp > score ) {
330 score = temp;
331 }
332 /* From state INSERT to state INSERT */
333 temp = SIG_0_1[INSERT] + mat->cp->trans[PCD_DELETE_2_BASE];
334 if( temp > score ) {
335 score = temp;
336 }
337 /* From state INSERT to state INSERT */
338 temp = SIG_0_4[INSERT] + mat->cp->trans[PCD_INSERT_1_BASE];
339 if( temp > score ) {
340 score = temp;
341 }
342 /* From state INSERT to state INSERT */
343 temp = SIG_0_5[INSERT] + mat->cp->trans[PCD_INSERT_2_BASE];
344 if( temp > score ) {
345 score = temp;
346 }
347 /* From state MATCH to state INSERT */
348 temp = SIG_0_2[MATCH] + mat->cp->trans[PCD_DELETE_1_BASE];
349 if( temp > score ) {
350 score = temp;
351 }
352 /* From state MATCH to state INSERT */
353 temp = SIG_0_1[MATCH] + mat->cp->trans[PCD_DELETE_2_BASE];
354 if( temp > score ) {
355 score = temp;
356 }
357 /* From state MATCH to state INSERT */
358 temp = SIG_0_4[MATCH] + mat->cp->trans[PCD_INSERT_1_BASE];
359 if( temp > score ) {
360 score = temp;
361 }
362 /* From state MATCH to state INSERT */
363 temp = SIG_0_5[MATCH] + mat->cp->trans[PCD_INSERT_2_BASE];
364 if( temp > score ) {
365 score = temp;
366 }
367 /* From state DELETE to state INSERT */
368 temp = SIG_0_2[DELETE] + mat->cp->trans[PCD_DELETE_1_BASE];
369 if( temp > score ) {
370 score = temp;
371 }
372 /* From state DELETE to state INSERT */
373 temp = SIG_0_1[DELETE] + mat->cp->trans[PCD_DELETE_2_BASE];
374 if( temp > score ) {
375 score = temp;
376 }
377 /* From state DELETE to state INSERT */
378 temp = SIG_0_4[DELETE] + mat->cp->trans[PCD_INSERT_1_BASE];
379 if( temp > score ) {
380 score = temp;
381 }
382 /* From state DELETE to state INSERT */
383 temp = SIG_0_5[DELETE] + mat->cp->trans[PCD_INSERT_2_BASE];
384 if( temp > score ) {
385 score = temp;
386 }
387
388
389 /* Ok - finished max calculation for INSERT */
390 /* Add any movement independant score and put away */
391 SIG_0_0[INSERT] = score;
392
393
394 /* state INSERT is a source for special END */
395 temp = score + (mat->query->seg[i]->transition[GW_INSERT2END]) + (0) ;
396 if( temp > EstWise3_SHATTER_SPECIAL(mat,i,j,END) ) {
397 EstWise3_SHATTER_SPECIAL(mat,i,j,END) = temp;
398 }
399
400
401
402
403 /* Finished calculating state INSERT */
404
405
406 /* For state DELETE */
407 /* setting first movement to score */
408 score = SIG_1_0[MATCH] + mat->query->seg[i]->transition[GW_MATCH2DELETE];
409 /* From state INSERT to state DELETE */
410 temp = SIG_1_0[INSERT] + mat->query->seg[i]->transition[GW_INSERT2DELETE];
411 if( temp > score ) {
412 score = temp;
413 }
414 /* From state DELETE to state DELETE */
415 temp = SIG_1_0[DELETE] + mat->query->seg[i]->transition[GW_DELETE2DELETE];
416 if( temp > score ) {
417 score = temp;
418 }
419 /* From state START to state DELETE */
420 temp = EstWise3_SHATTER_SPECIAL(mat,i-1,j-0,START) + mat->query->seg[i]->transition[GW_START2DELETE];
421 if( temp > score ) {
422 score = temp;
423 }
424
425
426 /* Ok - finished max calculation for DELETE */
427 /* Add any movement independant score and put away */
428 SIG_0_0[DELETE] = score;
429
430
431 /* state DELETE is a source for special END */
432 temp = score + (mat->query->seg[i]->transition[GW_DELETE2END]) + (0) ;
433 if( temp > EstWise3_SHATTER_SPECIAL(mat,i,j,END) ) {
434 EstWise3_SHATTER_SPECIAL(mat,i,j,END) = temp;
435 }
436
437
438
439
440 /* Finished calculating state DELETE */
441 }
442
443
444 /* Special state START has no special to special movements */
445
446
447 /* Special state END has no special to special movements */
448 }
449 stop_reporting();
450 return TRUE;
451 }
452
453
454 /* Function: search_EstWise3(dbsi,out,querydb,targetdb,cp)
455 *
456 * Descrip: This function makes a database search of EstWise3
457 * It uses the dbsi structure to choose which implementation
458 * to use of the database searching. This way at run time you
459 * can switch between single threaded/multi-threaded or hardware
460 *
461 *
462 * Arg: dbsi [UNKN ] Undocumented argument [DBSearchImpl *]
463 * Arg: out [UNKN ] Undocumented argument [Hscore *]
464 * Arg: querydb [UNKN ] Undocumented argument [GeneWiseDB*]
465 * Arg: targetdb [UNKN ] Undocumented argument [cDNADB*]
466 * Arg: cp [UNKN ] Undocumented argument [cDNAParserScore *]
467 *
468 * Return [UNKN ] Undocumented return value [Search_Return_Type]
469 *
470 */
search_EstWise3(DBSearchImpl * dbsi,Hscore * out,GeneWiseDB * querydb,cDNADB * targetdb,cDNAParserScore * cp)471 Search_Return_Type search_EstWise3(DBSearchImpl * dbsi,Hscore * out,GeneWiseDB* querydb,cDNADB* targetdb ,cDNAParserScore * cp)
472 {
473 #ifdef PTHREAD
474 int i;
475 int thr_no;
476 pthread_attr_t pat;
477 struct thread_pool_holder_EstWise3 * holder;
478 #endif
479 if( out == NULL ) {
480 warn("Passed in a null Hscore object into search_EstWise3. Can't process results!");
481 return SEARCH_ERROR;
482 }
483 if( dbsi == NULL ) {
484 warn("Passed in a null DBSearchImpl object into search_EstWise3. Can't process results!");
485 return SEARCH_ERROR;
486 }
487 if( dbsi->trace_level > 5 )
488 warn("Asking for trace level of %d in database search for EstWise3, but it was compiled with a trace level of -2139062144. Not all trace statements can be shown",dbsi->trace_level);
489 switch(dbsi->type) { /*switch on implementation*/
490 case DBSearchImpl_Serial :
491 return serial_search_EstWise3(out,querydb, targetdb ,cp);
492 case DBSearchImpl_Pthreads :
493 #ifdef PTHREAD
494 holder = (struct thread_pool_holder_EstWise3 *) ckalloc(sizeof(struct thread_pool_holder_EstWise3));
495 if( holder == NULL ) {
496 warn("Unable to allocated thread pool datastructure...");
497 return SEARCH_ERROR;
498 }
499 holder->out = out;
500 holder->dbsi = dbsi;
501 holder->querydb = querydb;
502 holder->targetdb = targetdb;
503 holder->cp = cp;
504 if( pthread_mutex_init(&(holder->input_lock),NULL) != 0 )
505 fatal("Unable to iniated input mutex lock");
506 if( pthread_mutex_init(&(holder->output_lock),NULL) != 0 )
507 fatal("Unable to iniated output mutex lock");
508 /* Let us rock! */
509 thr_no = number_of_threads_DBSearchImpl(dbsi);
510 holder->pool = ckcalloc (thr_no,sizeof(pthread_t));
511 if( holder->pool == NULL ) {
512 warn("Unable to allocated thread pools");
513 return SEARCH_ERROR;
514 }
515 /* Build a thread attribute to make sure we get the most out of SMP boxes */
516 pthread_attr_init(&pat);
517 /* Give thread libraries a hint that threads should be kernel threads */
518 #ifndef __sgi /* SGI can't set system scope ... */
519 #ifdef HAS_PTHREAD_SETSCOPE
520 pthread_attr_setscope(&pat, PTHREAD_SCOPE_SYSTEM);
521 #endif /* set scope */
522 #endif /* sgi */
523 /* Give thread libraries a hint that there are num of threads to run */
524 #ifdef HAS_PTHREAD_SETCONCURRENCY
525 pthread_setconcurrency(thr_no+1);
526 #endif /* set concurrency */
527 for(i=0;i<thr_no;i++) {
528 if( pthread_create(holder->pool+i,&pat,thread_loop_EstWise3,(void *)holder) )
529 fatal("Unable to create a thread!");
530 }
531 /* Now - wait for all the threads to exit */
532 for(i=0;i<thr_no;i++) {
533 if( pthread_join(holder->pool[i],NULL) != 0 )
534 fatal("Unable to join a thread!");
535 }
536 /* Deallocate the thread structures */
537 ckfree(holder->pool);
538 ckfree(holder);
539 return SEARCH_OK;
540 #else /* not compiled with threads */
541 warn("You did not specifiy the PTHREAD compile when compiled the C code for EstWise3");
542 #endif /* finished threads */
543 default :
544 warn("database search implementation %s was not provided in the compiled dynamite file from EstWise3",impl_string_DBSearchImpl(dbsi));
545 return SEARCH_ERROR;
546 } /* end of switch on implementation */
547
548
549 }
550
551
552 /* Function: thread_loop_EstWise3(ptr)
553 *
554 * Descrip: Infinite loop code foreach thread for EstWise3
555 *
556 *
557 * Arg: ptr [UNKN ] Undocumented argument [void *]
558 *
559 * Return [UNKN ] Undocumented return value [void *]
560 *
561 */
562 #ifdef PTHREAD
thread_loop_EstWise3(void * ptr)563 void * thread_loop_EstWise3(void * ptr)
564 {
565 struct thread_pool_holder_EstWise3 * holder;
566 int db_status;
567 int score;
568 DataScore * ds;
569 GeneWiseScore* query;
570 ComplexSequence* target;
571
572
573 holder = (struct thread_pool_holder_EstWise3 *) ptr;
574 if ( holder->dbsi->trace_level >= 1 )
575 fprintf(holder->dbsi->trace_file,"Entering infinite loop for thread...\n");
576
577
578 while(1) { /*Infinite loop over all models*/
579 /* Get input lock */
580
581
582 if ( holder->dbsi->trace_level >= 2 )
583 fprintf(holder->dbsi->trace_file,"About to get input lock for main reload\n");
584 if( pthread_mutex_lock(&(holder->input_lock))!= 0 )
585 fatal("Error on getting input lock for EstWise3");
586 if ( holder->dbsi->trace_level >= 2 )
587 fprintf(holder->dbsi->trace_file,"Got input lock for main reload\n");
588
589
590 if( holder->search_has_ended == TRUE ) {
591 if ( holder->dbsi->trace_level >= 2 )
592 fprintf(holder->dbsi->trace_file,"Database search finished for me!...\n");
593 if( pthread_mutex_unlock(&(holder->input_lock))!= 0 )
594 fatal("Error in releasing input lock for EstWise3");
595 if ( holder->dbsi->trace_level >= 2 )
596 fprintf(holder->dbsi->trace_file,"Released lock and broken out of loop\n");
597 break;
598 }
599
600
601 /* Get storage space now, as we have to read in the info for the db now */
602 if ( holder->dbsi->trace_level >= 3 )
603 fprintf(holder->dbsi->trace_file,"Getting new DataScore from storage...\n");
604 ds = new_DataScore();
605
606
607 /* We need to get our query object */
608 if ( holder->dbsi->trace_level >= 3 )
609 fprintf(holder->dbsi->trace_file,"Starting query database...\n");
610
611
612 if( holder->query_init == FALSE) {
613 holder->query = init_GeneWiseDB(holder->querydb,&db_status);
614 holder->query_init = TRUE;
615 if( db_status == DB_RETURN_ERROR )
616 fatal("Unable to initalise query database in EstWise3 search");
617 }
618 query = hard_link_GeneWiseScore(holder->query);
619 /* get query information into datascore */
620 dataentry_add_GeneWiseDB(ds->query,query,holder->querydb);
621
622
623 if( holder->target_init == FALSE ) { /*if the db has not been init'd*/
624 if ( holder->dbsi->trace_level >= 3 )
625 fprintf(holder->dbsi->trace_file,"Starting target database...\n");
626 target = init_cDNADB(holder->targetdb,&db_status);
627 holder->target_init = TRUE;
628 } /* end of if the db has not been init'd */
629 else { /*Normal reload*/
630 target = reload_cDNADB(NULL,holder->targetdb,&db_status);
631 } /* end of Normal reload */
632
633
634 /* Check to see what the reload is like */
635
636
637 if( db_status == DB_RETURN_ERROR ) {
638 fatal("In searching EstWise3, Reload error on database target, in threads");
639 }
640
641
642 if( db_status == DB_RETURN_END) { /*End of target database*/
643 /* close target database and schedule it for initalisation by next thread */
644 close_cDNADB(NULL,holder->targetdb);
645 holder->target_init = FALSE;
646 if ( holder->dbsi->trace_level >= 2 )
647 fprintf(holder->dbsi->trace_file,"Target Database to be reloaded...\n");
648
649
650 /* free'ing the query object */
651 free_GeneWiseScore(holder->query);
652 /* get the next query object for the next thread */
653 holder->query = reload_GeneWiseDB(NULL,holder->querydb,&db_status);
654 if( db_status == DB_RETURN_ERROR )
655 fatal("In searching EstWise3, reload error on database query, in threads");
656 if( db_status == DB_RETURN_END ) { /*last load!*/
657 /* End of target and query database - finished search! */
658 close_GeneWiseDB(NULL,holder->querydb);
659 holder->search_has_ended = TRUE;
660 } /* end of last load! */
661
662
663 /* release input mutex */
664 if ( holder->dbsi->trace_level >= 2 )
665 fprintf(holder->dbsi->trace_file,"Releasing input lock after end of target\n");
666 if( pthread_mutex_unlock(&(holder->input_lock))!= 0 )
667 fatal("Error in releasing input lock for EstWise3");
668 continue;
669 } /* end of End of target database */
670 else { /*Normal reload*/
671 if ( holder->dbsi->trace_level >= 2 )
672 fprintf(holder->dbsi->trace_file,"Releasing input lock for normal reload\n");
673 if( pthread_mutex_unlock(&(holder->input_lock))!= 0 )
674 fatal("Error in releasing input lock for EstWise3");
675 } /* end of Normal reload */
676 /* get target information into datascore */
677 dataentry_add_cDNADB(ds->target,target,holder->targetdb);
678
679
680 /* Now there is a new query/target pair ready for comparison */
681 if ( holder->dbsi->trace_level >= 1 )
682 fprintf(holder->dbsi->trace_file,"A new pair to be compared...\n");
683 score = score_only_EstWise3(query, target ,holder->cp);
684
685
686 if ( holder->dbsi->trace_level >= 2 )
687 fprintf(holder->dbsi->trace_file,"Getting output lock\n");
688 /* Getting lock on output */
689 if( pthread_mutex_lock(&(holder->output_lock))!= 0 )
690 fatal("Error on getting output lock for EstWise3");
691 /* If the score is less than cutoff, schedule the datascore for reuse */
692 if( should_store_Hscore(holder->out,score) != TRUE) {
693 free_DataScore(ds);
694 }
695 else { /*storing score*/
696 ds->score = score;
697 add_Hscore(holder->out,ds);
698 } /* end of storing score */
699 if( pthread_mutex_unlock(&(holder->output_lock))!= 0 )
700 fatal("Error on releasing output lock for EstWise3");
701 if ( holder->dbsi->trace_level >= 2 )
702 fprintf(holder->dbsi->trace_file,"Released output lock\n");
703
704
705 /* Now free database objects */
706 if ( holder->dbsi->trace_level >= 2 )
707 fprintf(holder->dbsi->trace_file,"About to get input lock for free func\n");
708 if( pthread_mutex_lock(&(holder->input_lock))!= 0 )
709 fatal("Error on getting input lock for EstWise3");
710 if ( holder->dbsi->trace_level >= 2 )
711 fprintf(holder->dbsi->trace_file,"Got input lock for free func\n");
712 free_GeneWiseScore(query);
713 free_ComplexSequence(target);
714 if ( holder->dbsi->trace_level >= 2 )
715 fprintf(holder->dbsi->trace_file,"Releasing input lock after free'ing\n");
716 if( pthread_mutex_unlock(&(holder->input_lock))!= 0 )
717 fatal("Error in releasing input lock for EstWise3");
718 } /* end of Infinite loop over all models */
719
720
721 if ( holder->dbsi->trace_level >= 1 )
722 fprintf(holder->dbsi->trace_file,"Exiting forever loop\n");
723 return NULL;
724 }
725
726
727 /* Function: serial_search_EstWise3(out,querydb,targetdb,cp)
728 *
729 * Descrip: This function makes a database search of EstWise3
730 * It is a single processor implementation
731 *
732 *
733 * Arg: out [UNKN ] Undocumented argument [Hscore *]
734 * Arg: querydb [UNKN ] Undocumented argument [GeneWiseDB*]
735 * Arg: targetdb [UNKN ] Undocumented argument [cDNADB*]
736 * Arg: cp [UNKN ] Undocumented argument [cDNAParserScore *]
737 *
738 * Return [UNKN ] Undocumented return value [Search_Return_Type]
739 *
740 */
741 #endif /* PTHREAD */
serial_search_EstWise3(Hscore * out,GeneWiseDB * querydb,cDNADB * targetdb,cDNAParserScore * cp)742 Search_Return_Type serial_search_EstWise3(Hscore * out,GeneWiseDB* querydb,cDNADB* targetdb ,cDNAParserScore * cp)
743 {
744 GeneWiseScore* query;
745 ComplexSequence* target;
746 int db_status;
747 int score;
748 int query_pos = 0;
749 int target_pos = 0;
750 DataScore * ds;
751
752
753 push_errormsg_stack("Before any actual search in db searching");
754 query = init_GeneWiseDB(querydb,&db_status);
755 if( db_status == DB_RETURN_ERROR ) {
756 warn("In searching EstWise3, got a database reload error on the query [query] database");
757 return SEARCH_ERROR;
758 }
759 for(;;) { /*For all query entries*/
760
761
762 target_pos = 0;
763
764
765 target = init_cDNADB(targetdb,&db_status);
766 if( db_status == DB_RETURN_ERROR ) {
767 warn("In searching EstWise3, got a database init error on the target [target] database");
768 return SEARCH_ERROR;
769 }
770 for(;;) { /*For all target entries*/
771
772
773 /* No maximum length - allocated on-the-fly */
774 score = score_only_EstWise3(query, target , cp);
775 if( should_store_Hscore(out,score) == TRUE ) { /*if storing datascore*/
776 ds = new_DataScore_from_storage(out);
777 if( ds == NULL ) {
778 warn("EstWise3 search had a memory error in allocating a new_DataScore (?a leak somewhere - DataScore is a very small datastructure");
779 return SEARCH_ERROR;
780 }
781 /* Now: add query/target information to the entry */
782 dataentry_add_GeneWiseDB(ds->query,query,querydb);
783 dataentry_add_cDNADB(ds->target,target,targetdb);
784 ds->score = score;
785 add_Hscore(out,ds);
786 } /* end of if storing datascore */
787 pop_errormsg_stack();
788 push_errormsg_stack("DB searching: just finished [Query Pos: %d] [Target Pos: %d]",query_pos,target_pos);
789
790
791 target = reload_cDNADB(target,targetdb,&db_status);
792 if( db_status == DB_RETURN_ERROR ) {
793 warn("In searching EstWise3, Reload error on database target, position %d,%d",query_pos,target_pos);
794 return SEARCH_ERROR;
795 }
796 if( db_status == DB_RETURN_END )
797 break;/* Out of target loop */
798 target_pos++;
799 } /* end of For all target entries */
800 close_cDNADB(target,targetdb);
801 query = reload_GeneWiseDB(query,querydb,&db_status);
802 if( db_status == DB_RETURN_ERROR) {
803 warn("In searching EstWise3, Reload error on database query, position %d,%d",query_pos,target_pos);
804 return SEARCH_ERROR;
805 }
806 if( db_status == DB_RETURN_END)
807 break; /* Out of query loop */
808 query_pos++;
809 } /* end of For all query entries */
810 close_GeneWiseDB(query,querydb);
811 pop_errormsg_stack();
812 return SEARCH_OK;
813 }
814
815
816 /* Function: score_only_EstWise3(query,target,cp)
817 *
818 * Descrip: This function just calculates the score for the matrix
819 * I am pretty sure we can do this better, but hey, for the moment...
820 * It calls /allocate_EstWise3_only
821 *
822 *
823 * Arg: query [UNKN ] query data structure [GeneWiseScore*]
824 * Arg: target [UNKN ] target data structure [ComplexSequence*]
825 * Arg: cp [UNKN ] Resource [cDNAParserScore *]
826 *
827 * Return [UNKN ] Undocumented return value [int]
828 *
829 */
score_only_EstWise3(GeneWiseScore * query,ComplexSequence * target,cDNAParserScore * cp)830 int score_only_EstWise3(GeneWiseScore* query,ComplexSequence* target ,cDNAParserScore * cp)
831 {
832 int bestscore = NEGI;
833 int i;
834 int j;
835 int k;
836 EstWise3 * mat;
837
838
839 mat = allocate_EstWise3_only(query, target , cp);
840 if( mat == NULL ) {
841 warn("Memory allocation error in the db search - unable to communicate to calling function. this spells DIASTER!");
842 return NEGI;
843 }
844 if((mat->basematrix = BaseMatrix_alloc_matrix_and_specials(6,(mat->leni + 1) * 3,6,2)) == NULL) {
845 warn("Score only matrix for EstWise3 cannot be allocated, (asking for 5 by %d cells)",mat->leni*3);
846 mat = free_EstWise3(mat);
847 return 0;
848 }
849 mat->basematrix->type = BASEMATRIX_TYPE_VERYSMALL;
850
851
852 /* Now, initiate matrix */
853 for(j=0;j<7;j++) {
854 for(i=(-1);i<mat->leni;i++) {
855 for(k=0;k<3;k++)
856 EstWise3_VSMALL_MATRIX(mat,i,j,k) = NEGI;
857 }
858 EstWise3_VSMALL_SPECIAL(mat,i,j,START) = 0;
859 EstWise3_VSMALL_SPECIAL(mat,i,j,END) = NEGI;
860 }
861
862
863 /* Ok, lets do-o-o-o-o it */
864
865
866 for(j=0;j<mat->lenj;j++) { /*for all target positions*/
867 auto int score;
868 auto int temp;
869 for(i=0;i<mat->leni;i++) { /*for all query positions*/
870
871
872 /* For state MATCH */
873 /* setting first movement to score */
874 score = EstWise3_VSMALL_MATRIX(mat,i-1,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
875 /* From state INSERT to state MATCH */
876 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
877 if( temp > score ) {
878 score = temp;
879 }
880 /* From state DELETE to state MATCH */
881 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
882 if( temp > score ) {
883 score = temp;
884 }
885 /* From state START to state MATCH */
886 temp = EstWise3_VSMALL_SPECIAL(mat,i-1,j-3,START) + (mat->query->seg[i]->transition[GW_START2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
887 if( temp > score ) {
888 score = temp;
889 }
890 /* From state MATCH to state MATCH */
891 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
892 if( temp > score ) {
893 score = temp;
894 }
895 /* From state MATCH to state MATCH */
896 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
897 if( temp > score ) {
898 score = temp;
899 }
900 /* From state MATCH to state MATCH */
901 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
902 if( temp > score ) {
903 score = temp;
904 }
905 /* From state MATCH to state MATCH */
906 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
907 if( temp > score ) {
908 score = temp;
909 }
910 /* From state INSERT to state MATCH */
911 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
912 if( temp > score ) {
913 score = temp;
914 }
915 /* From state INSERT to state MATCH */
916 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
917 if( temp > score ) {
918 score = temp;
919 }
920 /* From state INSERT to state MATCH */
921 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
922 if( temp > score ) {
923 score = temp;
924 }
925 /* From state INSERT to state MATCH */
926 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
927 if( temp > score ) {
928 score = temp;
929 }
930 /* From state DELETE to state MATCH */
931 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
932 if( temp > score ) {
933 score = temp;
934 }
935 /* From state DELETE to state MATCH */
936 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
937 if( temp > score ) {
938 score = temp;
939 }
940 /* From state DELETE to state MATCH */
941 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
942 if( temp > score ) {
943 score = temp;
944 }
945 /* From state DELETE to state MATCH */
946 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
947 if( temp > score ) {
948 score = temp;
949 }
950
951
952 /* Ok - finished max calculation for MATCH */
953 /* Add any movement independant score and put away */
954 EstWise3_VSMALL_MATRIX(mat,i,j,MATCH) = score;
955
956
957 /* state MATCH is a source for special END */
958 temp = score + (mat->query->seg[i]->transition[GW_MATCH2END]) + (0) ;
959 if( temp > EstWise3_VSMALL_SPECIAL(mat,i,j,END) ) {
960 EstWise3_VSMALL_SPECIAL(mat,i,j,END) = temp;
961 }
962
963
964
965
966 /* Finished calculating state MATCH */
967
968
969 /* For state INSERT */
970 /* setting first movement to score */
971 score = EstWise3_VSMALL_MATRIX(mat,i-0,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
972 /* From state INSERT to state INSERT */
973 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
974 if( temp > score ) {
975 score = temp;
976 }
977 /* From state DELETE to state INSERT */
978 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
979 if( temp > score ) {
980 score = temp;
981 }
982 /* From state START to state INSERT */
983 temp = EstWise3_VSMALL_SPECIAL(mat,i-0,j-3,START) + (mat->query->seg[i]->transition[GW_START2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
984 if( temp > score ) {
985 score = temp;
986 }
987 /* From state INSERT to state INSERT */
988 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
989 if( temp > score ) {
990 score = temp;
991 }
992 /* From state INSERT to state INSERT */
993 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
994 if( temp > score ) {
995 score = temp;
996 }
997 /* From state INSERT to state INSERT */
998 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
999 if( temp > score ) {
1000 score = temp;
1001 }
1002 /* From state INSERT to state INSERT */
1003 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
1004 if( temp > score ) {
1005 score = temp;
1006 }
1007 /* From state MATCH to state INSERT */
1008 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
1009 if( temp > score ) {
1010 score = temp;
1011 }
1012 /* From state MATCH to state INSERT */
1013 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
1014 if( temp > score ) {
1015 score = temp;
1016 }
1017 /* From state MATCH to state INSERT */
1018 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
1019 if( temp > score ) {
1020 score = temp;
1021 }
1022 /* From state MATCH to state INSERT */
1023 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
1024 if( temp > score ) {
1025 score = temp;
1026 }
1027 /* From state DELETE to state INSERT */
1028 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
1029 if( temp > score ) {
1030 score = temp;
1031 }
1032 /* From state DELETE to state INSERT */
1033 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
1034 if( temp > score ) {
1035 score = temp;
1036 }
1037 /* From state DELETE to state INSERT */
1038 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
1039 if( temp > score ) {
1040 score = temp;
1041 }
1042 /* From state DELETE to state INSERT */
1043 temp = EstWise3_VSMALL_MATRIX(mat,i-0,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
1044 if( temp > score ) {
1045 score = temp;
1046 }
1047
1048
1049 /* Ok - finished max calculation for INSERT */
1050 /* Add any movement independant score and put away */
1051 EstWise3_VSMALL_MATRIX(mat,i,j,INSERT) = score;
1052
1053
1054 /* state INSERT is a source for special END */
1055 temp = score + (mat->query->seg[i]->transition[GW_INSERT2END]) + (0) ;
1056 if( temp > EstWise3_VSMALL_SPECIAL(mat,i,j,END) ) {
1057 EstWise3_VSMALL_SPECIAL(mat,i,j,END) = temp;
1058 }
1059
1060
1061
1062
1063 /* Finished calculating state INSERT */
1064
1065
1066 /* For state DELETE */
1067 /* setting first movement to score */
1068 score = EstWise3_VSMALL_MATRIX(mat,i-1,j-0,MATCH) + mat->query->seg[i]->transition[GW_MATCH2DELETE];
1069 /* From state INSERT to state DELETE */
1070 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-0,INSERT) + mat->query->seg[i]->transition[GW_INSERT2DELETE];
1071 if( temp > score ) {
1072 score = temp;
1073 }
1074 /* From state DELETE to state DELETE */
1075 temp = EstWise3_VSMALL_MATRIX(mat,i-1,j-0,DELETE) + mat->query->seg[i]->transition[GW_DELETE2DELETE];
1076 if( temp > score ) {
1077 score = temp;
1078 }
1079 /* From state START to state DELETE */
1080 temp = EstWise3_VSMALL_SPECIAL(mat,i-1,j-0,START) + mat->query->seg[i]->transition[GW_START2DELETE];
1081 if( temp > score ) {
1082 score = temp;
1083 }
1084
1085
1086 /* Ok - finished max calculation for DELETE */
1087 /* Add any movement independant score and put away */
1088 EstWise3_VSMALL_MATRIX(mat,i,j,DELETE) = score;
1089
1090
1091 /* state DELETE is a source for special END */
1092 temp = score + (mat->query->seg[i]->transition[GW_DELETE2END]) + (0) ;
1093 if( temp > EstWise3_VSMALL_SPECIAL(mat,i,j,END) ) {
1094 EstWise3_VSMALL_SPECIAL(mat,i,j,END) = temp;
1095 }
1096
1097
1098
1099
1100 /* Finished calculating state DELETE */
1101 } /* end of for all query positions */
1102
1103
1104
1105
1106 /* Special state START has no special to special movements */
1107
1108
1109 /* Special state END has no special to special movements */
1110 if( bestscore < EstWise3_VSMALL_SPECIAL(mat,0,j,END) )
1111 bestscore = EstWise3_VSMALL_SPECIAL(mat,0,j,END);
1112 } /* end of for all target positions */
1113
1114
1115 mat = free_EstWise3(mat);
1116 return bestscore;
1117 }
1118
1119
1120 /* Function: PackAln_bestmemory_EstWise3(query,target,cp,dpenv,dpri)
1121 *
1122 * Descrip: This function chooses the best memory set-up for the alignment
1123 * using calls to basematrix, and then implements either a large
1124 * or small memory model.
1125 *
1126 * It is the best function to use if you just want an alignment
1127 *
1128 * If you want a label alignment, you will need
1129 * /convert_PackAln_to_AlnBlock_EstWise3
1130 *
1131 *
1132 * Arg: query [UNKN ] query data structure [GeneWiseScore*]
1133 * Arg: target [UNKN ] target data structure [ComplexSequence*]
1134 * Arg: cp [UNKN ] Resource [cDNAParserScore *]
1135 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
1136 * Arg: dpri [UNKN ] Undocumented argument [DPRunImpl *]
1137 *
1138 * Return [UNKN ] Undocumented return value [PackAln *]
1139 *
1140 */
PackAln_bestmemory_EstWise3(GeneWiseScore * query,ComplexSequence * target,cDNAParserScore * cp,DPEnvelope * dpenv,DPRunImpl * dpri)1141 PackAln * PackAln_bestmemory_EstWise3(GeneWiseScore* query,ComplexSequence* target ,cDNAParserScore * cp,DPEnvelope * dpenv,DPRunImpl * dpri)
1142 {
1143 long long total;
1144 EstWise3 * mat;
1145 PackAln * out;
1146 DebugMatrix * de;
1147 DPRunImplMemory strategy;
1148 assert(dpri);
1149
1150
1151 total = query->len * target->seq->len;
1152 if( dpri->memory == DPIM_Default ) {
1153 if( (total * 3 * sizeof(int)) > 1000*dpri->kbyte_size) {
1154 strategy = DPIM_Linear;
1155 }
1156 else {
1157 strategy = DPIM_Explicit;
1158 }
1159 }
1160 else {
1161 strategy = dpri->memory;
1162 }
1163
1164
1165 if( dpenv != NULL ) {
1166 if( strategy == DPIM_Explicit) {
1167 if( (mat=allocate_Expl_EstWise3(query, target , cp,dpri)) == NULL ) {
1168 warn("Unable to allocate large EstWise3 version");
1169 return NULL;
1170 }
1171 calculate_dpenv_EstWise3(mat,dpenv);
1172 out = PackAln_read_Expl_EstWise3(mat);
1173 }
1174 else {
1175 mat = allocate_EstWise3_only(query, target , cp);
1176 calculate_shatter_EstWise3(mat,dpenv);
1177 out = PackAln_read_Shatter_EstWise3(mat);
1178 }
1179 }
1180 else {
1181 if( strategy == DPIM_Linear ) {
1182 /* use small implementation */
1183 if( (mat=allocate_Small_EstWise3(query, target , cp)) == NULL ) {
1184 warn("Unable to allocate small EstWise3 version");
1185 return NULL;
1186 }
1187 out = PackAln_calculate_Small_EstWise3(mat,dpenv);
1188 }
1189 else {
1190 /* use Large implementation */
1191 if( (mat=allocate_Expl_EstWise3(query, target , cp,dpri)) == NULL ) {
1192 warn("Unable to allocate large EstWise3 version");
1193 return NULL;
1194 }
1195 if( dpri->debug == TRUE) {
1196 fatal("Asked for dydebug, but dynamite file not compiled with -g. Need to recompile dynamite source");
1197 }
1198 else {
1199 calculate_EstWise3(mat);
1200 out = PackAln_read_Expl_EstWise3(mat);
1201 }
1202 }
1203 }
1204
1205
1206 mat = free_EstWise3(mat);
1207 return out;
1208 }
1209
1210
1211 /* Function: allocate_EstWise3_only(query,target,cp)
1212 *
1213 * Descrip: This function only allocates the EstWise3 structure
1214 * checks types where possible and determines leni and lenj
1215 * The basematrix area is delt with elsewhere
1216 *
1217 *
1218 * Arg: query [UNKN ] query data structure [GeneWiseScore*]
1219 * Arg: target [UNKN ] target data structure [ComplexSequence*]
1220 * Arg: cp [UNKN ] Resource [cDNAParserScore *]
1221 *
1222 * Return [UNKN ] Undocumented return value [EstWise3 *]
1223 *
1224 */
allocate_EstWise3_only(GeneWiseScore * query,ComplexSequence * target,cDNAParserScore * cp)1225 EstWise3 * allocate_EstWise3_only(GeneWiseScore* query,ComplexSequence* target ,cDNAParserScore * cp)
1226 {
1227 EstWise3 * out;
1228
1229
1230 if((out= EstWise3_alloc()) == NULL) {
1231 warn("Allocation of basic EstWise3 structure failed...");
1232 return NULL;
1233 }
1234
1235
1236 out->query = query;
1237 out->target = target;
1238 out->cp = cp;
1239 out->leni = query->len;
1240 out->lenj = target->seq->len;
1241 return out;
1242 }
1243
1244
1245 /* Function: allocate_Expl_EstWise3(query,target,cp,dpri)
1246 *
1247 * Descrip: This function allocates the EstWise3 structure
1248 * and the basematrix area for explicit memory implementations
1249 * It calls /allocate_EstWise3_only
1250 *
1251 *
1252 * Arg: query [UNKN ] query data structure [GeneWiseScore*]
1253 * Arg: target [UNKN ] target data structure [ComplexSequence*]
1254 * Arg: cp [UNKN ] Resource [cDNAParserScore *]
1255 * Arg: dpri [UNKN ] Undocumented argument [DPRunImpl *]
1256 *
1257 * Return [UNKN ] Undocumented return value [EstWise3 *]
1258 *
1259 */
allocate_Expl_EstWise3(GeneWiseScore * query,ComplexSequence * target,cDNAParserScore * cp,DPRunImpl * dpri)1260 EstWise3 * allocate_Expl_EstWise3(GeneWiseScore* query,ComplexSequence* target ,cDNAParserScore * cp,DPRunImpl * dpri)
1261 {
1262 EstWise3 * out;
1263
1264
1265 out = allocate_EstWise3_only(query, target , cp);
1266 if( out == NULL )
1267 return NULL;
1268 if( dpri->should_cache == TRUE ) {
1269 if( dpri->cache != NULL ) {
1270 if( dpri->cache->maxleni >= (out->lenj+5)*3 && dpri->cache->maxlenj >= (out->leni+1))
1271 out->basematrix = hard_link_BaseMatrix(dpri->cache);
1272 else
1273 dpri->cache = free_BaseMatrix(dpri->cache);
1274 }
1275 }
1276 if( out->basematrix == NULL ) {
1277 if( (out->basematrix = BaseMatrix_alloc_matrix_and_specials((out->lenj+5)*3,(out->leni+1),2,out->lenj+5)) == NULL) {
1278 warn("Explicit matrix EstWise3 cannot be allocated, (asking for %d by %d main cells)",out->leni,out->lenj);
1279 free_EstWise3(out);
1280 return NULL;
1281 }
1282 }
1283 if( dpri->should_cache == TRUE && dpri->cache == NULL)
1284 dpri->cache = hard_link_BaseMatrix(out->basematrix);
1285 out->basematrix->type = BASEMATRIX_TYPE_EXPLICIT;
1286 init_EstWise3(out);
1287 return out;
1288 }
1289
1290
1291 /* Function: init_EstWise3(mat)
1292 *
1293 * Descrip: This function initates EstWise3 matrix when in explicit mode
1294 * Called in /allocate_Expl_EstWise3
1295 *
1296 *
1297 * Arg: mat [UNKN ] EstWise3 which contains explicit basematrix memory [EstWise3 *]
1298 *
1299 */
init_EstWise3(EstWise3 * mat)1300 void init_EstWise3(EstWise3 * mat)
1301 {
1302 register int i;
1303 register int j;
1304 if( mat->basematrix->type != BASEMATRIX_TYPE_EXPLICIT) {
1305 warn("Cannot iniate matrix, is not an explicit memory type and you have assummed that");
1306 return;
1307 }
1308
1309
1310 for(i= (-1);i<mat->query->len;i++) {
1311 for(j= (-5);j<6;j++) {
1312 EstWise3_EXPL_MATRIX(mat,i,j,MATCH) = NEGI;
1313 EstWise3_EXPL_MATRIX(mat,i,j,INSERT) = NEGI;
1314 EstWise3_EXPL_MATRIX(mat,i,j,DELETE) = NEGI;
1315 }
1316 }
1317 for(j= (-5);j<mat->target->seq->len;j++) {
1318 for(i= (-1);i<2;i++) {
1319 EstWise3_EXPL_MATRIX(mat,i,j,MATCH) = NEGI;
1320 EstWise3_EXPL_MATRIX(mat,i,j,INSERT) = NEGI;
1321 EstWise3_EXPL_MATRIX(mat,i,j,DELETE) = NEGI;
1322 }
1323 EstWise3_EXPL_SPECIAL(mat,i,j,START) = 0;
1324 EstWise3_EXPL_SPECIAL(mat,i,j,END) = NEGI;
1325 }
1326 return;
1327 }
1328
1329
1330 /* Function: recalculate_PackAln_EstWise3(pal,mat)
1331 *
1332 * Descrip: This function recalculates the PackAln structure produced by EstWise3
1333 * For example, in linear space methods this is used to score them
1334 *
1335 *
1336 * Arg: pal [UNKN ] Undocumented argument [PackAln *]
1337 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
1338 *
1339 */
recalculate_PackAln_EstWise3(PackAln * pal,EstWise3 * mat)1340 void recalculate_PackAln_EstWise3(PackAln * pal,EstWise3 * mat)
1341 {
1342 int i,j,k,offi,offj;
1343 PackAlnUnit * prev;
1344 PackAlnUnit * pau;
1345
1346
1347 for(k=1,prev=pal->pau[0];k < pal->len;k++,prev=pau) {
1348 pau = pal->pau[k];
1349 i = pau->i;
1350 j = pau->j;
1351 offi = pau->i - prev->i;
1352 offj = pau->j - prev->j;
1353 switch(pau->state) {
1354 case MATCH :
1355 if( offi == 1 && offj == 3 && prev->state == MATCH ) {
1356 pau->score = (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
1357 continue;
1358 }
1359 if( offi == 1 && offj == 3 && prev->state == INSERT ) {
1360 pau->score = (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
1361 continue;
1362 }
1363 if( offi == 1 && offj == 3 && prev->state == DELETE ) {
1364 pau->score = (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
1365 continue;
1366 }
1367 if( offj == 3 && prev->state == (START+3) ) {
1368 pau->score = (mat->query->seg[i]->transition[GW_START2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
1369 continue;
1370 }
1371 if( offi == 1 && offj == 2 && prev->state == MATCH ) {
1372 pau->score = mat->cp->trans[PCD_DELETE_1_BASE] + (0);
1373 continue;
1374 }
1375 if( offi == 1 && offj == 1 && prev->state == MATCH ) {
1376 pau->score = mat->cp->trans[PCD_DELETE_2_BASE] + (0);
1377 continue;
1378 }
1379 if( offi == 1 && offj == 4 && prev->state == MATCH ) {
1380 pau->score = mat->cp->trans[PCD_INSERT_1_BASE] + (0);
1381 continue;
1382 }
1383 if( offi == 1 && offj == 5 && prev->state == MATCH ) {
1384 pau->score = mat->cp->trans[PCD_INSERT_2_BASE] + (0);
1385 continue;
1386 }
1387 if( offi == 1 && offj == 2 && prev->state == INSERT ) {
1388 pau->score = mat->cp->trans[PCD_DELETE_1_BASE] + (0);
1389 continue;
1390 }
1391 if( offi == 1 && offj == 1 && prev->state == INSERT ) {
1392 pau->score = mat->cp->trans[PCD_DELETE_2_BASE] + (0);
1393 continue;
1394 }
1395 if( offi == 1 && offj == 4 && prev->state == INSERT ) {
1396 pau->score = mat->cp->trans[PCD_INSERT_1_BASE] + (0);
1397 continue;
1398 }
1399 if( offi == 1 && offj == 5 && prev->state == INSERT ) {
1400 pau->score = mat->cp->trans[PCD_INSERT_2_BASE] + (0);
1401 continue;
1402 }
1403 if( offi == 1 && offj == 2 && prev->state == DELETE ) {
1404 pau->score = mat->cp->trans[PCD_DELETE_1_BASE] + (0);
1405 continue;
1406 }
1407 if( offi == 1 && offj == 1 && prev->state == DELETE ) {
1408 pau->score = mat->cp->trans[PCD_DELETE_2_BASE] + (0);
1409 continue;
1410 }
1411 if( offi == 1 && offj == 4 && prev->state == DELETE ) {
1412 pau->score = mat->cp->trans[PCD_INSERT_1_BASE] + (0);
1413 continue;
1414 }
1415 if( offi == 1 && offj == 5 && prev->state == DELETE ) {
1416 pau->score = mat->cp->trans[PCD_INSERT_2_BASE] + (0);
1417 continue;
1418 }
1419 warn("In recaluclating PackAln with state MATCH, from [%d,%d,%d], got a bad source state. Error!",offi,offj,prev->state);
1420 break;
1421 case INSERT :
1422 if( offi == 0 && offj == 3 && prev->state == MATCH ) {
1423 pau->score = (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
1424 continue;
1425 }
1426 if( offi == 0 && offj == 3 && prev->state == INSERT ) {
1427 pau->score = (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
1428 continue;
1429 }
1430 if( offi == 0 && offj == 3 && prev->state == DELETE ) {
1431 pau->score = (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
1432 continue;
1433 }
1434 if( offj == 3 && prev->state == (START+3) ) {
1435 pau->score = (mat->query->seg[i]->transition[GW_START2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
1436 continue;
1437 }
1438 if( offi == 0 && offj == 2 && prev->state == INSERT ) {
1439 pau->score = mat->cp->trans[PCD_DELETE_1_BASE] + (0);
1440 continue;
1441 }
1442 if( offi == 0 && offj == 1 && prev->state == INSERT ) {
1443 pau->score = mat->cp->trans[PCD_DELETE_2_BASE] + (0);
1444 continue;
1445 }
1446 if( offi == 0 && offj == 4 && prev->state == INSERT ) {
1447 pau->score = mat->cp->trans[PCD_INSERT_1_BASE] + (0);
1448 continue;
1449 }
1450 if( offi == 0 && offj == 5 && prev->state == INSERT ) {
1451 pau->score = mat->cp->trans[PCD_INSERT_2_BASE] + (0);
1452 continue;
1453 }
1454 if( offi == 0 && offj == 2 && prev->state == MATCH ) {
1455 pau->score = mat->cp->trans[PCD_DELETE_1_BASE] + (0);
1456 continue;
1457 }
1458 if( offi == 0 && offj == 1 && prev->state == MATCH ) {
1459 pau->score = mat->cp->trans[PCD_DELETE_2_BASE] + (0);
1460 continue;
1461 }
1462 if( offi == 0 && offj == 4 && prev->state == MATCH ) {
1463 pau->score = mat->cp->trans[PCD_INSERT_1_BASE] + (0);
1464 continue;
1465 }
1466 if( offi == 0 && offj == 5 && prev->state == MATCH ) {
1467 pau->score = mat->cp->trans[PCD_INSERT_2_BASE] + (0);
1468 continue;
1469 }
1470 if( offi == 0 && offj == 2 && prev->state == DELETE ) {
1471 pau->score = mat->cp->trans[PCD_DELETE_1_BASE] + (0);
1472 continue;
1473 }
1474 if( offi == 0 && offj == 1 && prev->state == DELETE ) {
1475 pau->score = mat->cp->trans[PCD_DELETE_2_BASE] + (0);
1476 continue;
1477 }
1478 if( offi == 0 && offj == 4 && prev->state == DELETE ) {
1479 pau->score = mat->cp->trans[PCD_INSERT_1_BASE] + (0);
1480 continue;
1481 }
1482 if( offi == 0 && offj == 5 && prev->state == DELETE ) {
1483 pau->score = mat->cp->trans[PCD_INSERT_2_BASE] + (0);
1484 continue;
1485 }
1486 warn("In recaluclating PackAln with state INSERT, from [%d,%d,%d], got a bad source state. Error!",offi,offj,prev->state);
1487 break;
1488 case DELETE :
1489 if( offi == 1 && offj == 0 && prev->state == MATCH ) {
1490 pau->score = mat->query->seg[i]->transition[GW_MATCH2DELETE] + (0);
1491 continue;
1492 }
1493 if( offi == 1 && offj == 0 && prev->state == INSERT ) {
1494 pau->score = mat->query->seg[i]->transition[GW_INSERT2DELETE] + (0);
1495 continue;
1496 }
1497 if( offi == 1 && offj == 0 && prev->state == DELETE ) {
1498 pau->score = mat->query->seg[i]->transition[GW_DELETE2DELETE] + (0);
1499 continue;
1500 }
1501 if( offj == 0 && prev->state == (START+3) ) {
1502 pau->score = mat->query->seg[i]->transition[GW_START2DELETE] + (0);
1503 continue;
1504 }
1505 warn("In recaluclating PackAln with state DELETE, from [%d,%d,%d], got a bad source state. Error!",offi,offj,prev->state);
1506 break;
1507 case (START+3) :
1508 warn("In recaluclating PackAln with state START, got a bad source state. Error!");
1509 break;
1510 case (END+3) :
1511 if( offj == 0 && prev->state == MATCH ) {
1512 /* i here comes from the previous state ;) - not the real one */
1513 i = prev->i;
1514 pau->score = mat->query->seg[i]->transition[GW_MATCH2END] + (0);
1515 continue;
1516 }
1517 if( offj == 0 && prev->state == INSERT ) {
1518 /* i here comes from the previous state ;) - not the real one */
1519 i = prev->i;
1520 pau->score = mat->query->seg[i]->transition[GW_INSERT2END] + (0);
1521 continue;
1522 }
1523 if( offj == 0 && prev->state == DELETE ) {
1524 /* i here comes from the previous state ;) - not the real one */
1525 i = prev->i;
1526 pau->score = mat->query->seg[i]->transition[GW_DELETE2END] + (0);
1527 continue;
1528 }
1529 warn("In recaluclating PackAln with state END, got a bad source state. Error!");
1530 break;
1531 default :
1532 warn("In recaluclating PackAln got a bad recipient state. Error!");
1533 }
1534 prev = pau;
1535 }
1536 return;
1537 }
1538 /* divide and conquor macros are next */
1539 #define EstWise3_HIDDEN_MATRIX(thismatrix,i,j,state) (thismatrix->basematrix->matrix[(j-hiddenj+5)][(i+1)*3+state])
1540 #define EstWise3_DC_SHADOW_MATRIX(thismatrix,i,j,state) (thismatrix->basematrix->matrix[((j+6)*8) % 48][(i+1)*3+state])
1541 #define EstWise3_HIDDEN_SPECIAL(thismatrix,i,j,state) (thismatrix->basematrix->specmatrix[state][(j+5)])
1542 #define EstWise3_DC_SHADOW_SPECIAL(thismatrix,i,j,state) (thismatrix->basematrix->specmatrix[state*8][(j+5)])
1543 #define EstWise3_DC_SHADOW_MATRIX_SP(thismatrix,i,j,state,shadow) (thismatrix->basematrix->matrix[((((j+6)*8)+(shadow+1)) % 48)][(i+1)*3 + state])
1544 #define EstWise3_DC_SHADOW_SPECIAL_SP(thismatrix,i,j,state,shadow) (thismatrix->basematrix->specmatrix[state*8 +shadow+1][(j+5)])
1545 #define EstWise3_DC_OPT_SHADOW_MATRIX(thismatrix,i,j,state) (score_pointers[(((j+5)% 5) * (leni+1) * 3) + ((i+1) * 3) + (state)])
1546 #define EstWise3_DC_OPT_SHADOW_MATRIX_SP(thismatrix,i,j,state,shadow) (shadow_pointers[(((j+5)% 5) * (leni+1) * 24) + ((i+1) * 24) + (state * 8) + shadow+1])
1547 #define EstWise3_DC_OPT_SHADOW_SPECIAL(thismatrix,i,j,state) (thismatrix->basematrix->specmatrix[state*8][(j+5)])
1548 /* Function: allocate_Small_EstWise3(query,target,cp)
1549 *
1550 * Descrip: This function allocates the EstWise3 structure
1551 * and the basematrix area for a small memory implementations
1552 * It calls /allocate_EstWise3_only
1553 *
1554 *
1555 * Arg: query [UNKN ] query data structure [GeneWiseScore*]
1556 * Arg: target [UNKN ] target data structure [ComplexSequence*]
1557 * Arg: cp [UNKN ] Resource [cDNAParserScore *]
1558 *
1559 * Return [UNKN ] Undocumented return value [EstWise3 *]
1560 *
1561 */
1562 #define EstWise3_DC_OPT_SHADOW_SPECIAL_SP(thismatrix,i,j,state,shadow) (thismatrix->basematrix->specmatrix[state*8 +shadow+1][(j+5)])
allocate_Small_EstWise3(GeneWiseScore * query,ComplexSequence * target,cDNAParserScore * cp)1563 EstWise3 * allocate_Small_EstWise3(GeneWiseScore* query,ComplexSequence* target ,cDNAParserScore * cp)
1564 {
1565 EstWise3 * out;
1566
1567
1568 out = allocate_EstWise3_only(query, target , cp);
1569 if( out == NULL )
1570 return NULL;
1571 out->basematrix = BaseMatrix_alloc_matrix_and_specials(48,(out->leni + 1) * 3,16,out->lenj+5);
1572 if(out == NULL) {
1573 warn("Small shadow matrix EstWise3 cannot be allocated, (asking for 6 by %d main cells)",out->leni+2);
1574 free_EstWise3(out);
1575 return NULL;
1576 }
1577 out->basematrix->type = BASEMATRIX_TYPE_SHADOW;
1578 return out;
1579 }
1580
1581
1582 /* Function: PackAln_calculate_Small_EstWise3(mat,dpenv)
1583 *
1584 * Descrip: This function calculates an alignment for EstWise3 structure in linear space
1585 * If you want only the start/end points
1586 * use /AlnRangeSet_calculate_Small_EstWise3
1587 *
1588 * The function basically
1589 * finds start/end points
1590 * foreach start/end point
1591 * calls /full_dc_EstWise3
1592 *
1593 *
1594 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
1595 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
1596 *
1597 * Return [UNKN ] Undocumented return value [PackAln *]
1598 *
1599 */
PackAln_calculate_Small_EstWise3(EstWise3 * mat,DPEnvelope * dpenv)1600 PackAln * PackAln_calculate_Small_EstWise3(EstWise3 * mat,DPEnvelope * dpenv)
1601 {
1602 int endj;
1603 int score;
1604 PackAln * out;
1605 PackAlnUnit * pau;
1606 int starti;
1607 int startj;
1608 int startstate;
1609 int stopi;
1610 int stopj;
1611 int stopstate;
1612 int temp;
1613 int donej; /* This is for reporting, will be passed as a & arg in */
1614 int totalj; /* This also is for reporting, but as is not changed, can be passed by value */
1615
1616
1617 if( mat->basematrix->type != BASEMATRIX_TYPE_SHADOW ) {
1618 warn("Could not calculate packaln small for EstWise3 due to wrong type of matrix");
1619 return NULL;
1620 }
1621
1622
1623 out = PackAln_alloc_std();
1624
1625
1626 start_reporting("Find start end points: ");
1627 dc_optimised_start_end_calc_EstWise3(mat,dpenv);
1628 score = start_end_find_end_EstWise3(mat,&endj);
1629 out->score = score;
1630 stopstate = END;
1631
1632 /* No special to specials: one matrix alignment: simply remove and get */
1633 starti = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,endj,END,0);
1634 startj = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,endj,END,1);
1635 startstate = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,endj,END,2);
1636 stopi = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,endj,END,3);
1637 stopj = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,endj,END,4);
1638 stopstate = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,endj,END,5);
1639 temp = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,endj,END,6);
1640 log_full_error(REPORT,0,"[%d,%d][%d,%d] Score %d",starti,startj,stopi,stopj,score);
1641 stop_reporting();
1642 start_reporting("Recovering alignment: ");
1643
1644
1645 /* Figuring how much j we have to align for reporting purposes */
1646 donej = 0;
1647 totalj = stopj - startj;
1648 full_dc_EstWise3(mat,starti,startj,startstate,stopi,stopj,stopstate,out,&donej,totalj,dpenv);
1649
1650
1651 /* Although we have no specials, need to get start. Better to check than assume */
1652
1653
1654 max_matrix_to_special_EstWise3(mat,starti,startj,startstate,temp,&stopi,&stopj,&stopstate,&temp,NULL);
1655 if( stopi == EstWise3_READ_OFF_ERROR || stopstate != START ) {
1656 warn("Problem in reading off special state system, hit a non start state (or an internal error) in a single alignment mode");
1657 invert_PackAln(out);
1658 recalculate_PackAln_EstWise3(out,mat);
1659 return out;
1660 }
1661
1662
1663 /* Ok. Put away start start... */
1664 pau = PackAlnUnit_alloc();
1665 pau->i = stopi;
1666 pau->j = stopj;
1667 pau->state = stopstate + 3;
1668 add_PackAln(out,pau);
1669
1670
1671 log_full_error(REPORT,0,"Alignment recovered");
1672 stop_reporting();
1673 invert_PackAln(out);
1674 recalculate_PackAln_EstWise3(out,mat);
1675 return out;
1676
1677
1678 }
1679
1680
1681 /* Function: AlnRangeSet_calculate_Small_EstWise3(mat)
1682 *
1683 * Descrip: This function calculates an alignment for EstWise3 structure in linear space
1684 * If you want the full alignment, use /PackAln_calculate_Small_EstWise3
1685 * If you have already got the full alignment, but want the range set, use /AlnRangeSet_from_PackAln_EstWise3
1686 * If you have got the small matrix but not the alignment, use /AlnRangeSet_from_EstWise3
1687 *
1688 *
1689 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
1690 *
1691 * Return [UNKN ] Undocumented return value [AlnRangeSet *]
1692 *
1693 */
AlnRangeSet_calculate_Small_EstWise3(EstWise3 * mat)1694 AlnRangeSet * AlnRangeSet_calculate_Small_EstWise3(EstWise3 * mat)
1695 {
1696 AlnRangeSet * out;
1697
1698
1699 start_reporting("Find start end points: ");
1700 dc_optimised_start_end_calc_EstWise3(mat,NULL);
1701 log_full_error(REPORT,0,"Calculated");
1702
1703
1704 out = AlnRangeSet_from_EstWise3(mat);
1705 return out;
1706 }
1707
1708
1709 /* Function: AlnRangeSet_from_EstWise3(mat)
1710 *
1711 * Descrip: This function reads off a start/end structure
1712 * for EstWise3 structure in linear space
1713 * If you want the full alignment use
1714 * /PackAln_calculate_Small_EstWise3
1715 * If you have not calculated the matrix use
1716 * /AlnRange_calculate_Small_EstWise3
1717 *
1718 *
1719 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
1720 *
1721 * Return [UNKN ] Undocumented return value [AlnRangeSet *]
1722 *
1723 */
AlnRangeSet_from_EstWise3(EstWise3 * mat)1724 AlnRangeSet * AlnRangeSet_from_EstWise3(EstWise3 * mat)
1725 {
1726 AlnRangeSet * out;
1727 AlnRange * temp;
1728 int jpos;
1729 int state;
1730
1731
1732 if( mat->basematrix->type != BASEMATRIX_TYPE_SHADOW) {
1733 warn("Bad error! - non shadow matrix type in AlnRangeSet_from_EstWise3");
1734 return NULL;
1735 }
1736
1737
1738 out = AlnRangeSet_alloc_std();
1739 /* Find the end position */
1740 out->score = start_end_find_end_EstWise3(mat,&jpos);
1741 state = END;
1742
1743
1744 while( (temp = AlnRange_build_EstWise3(mat,jpos,state,&jpos,&state)) != NULL)
1745 add_AlnRangeSet(out,temp);
1746 return out;
1747 }
1748
1749
1750 /* Function: AlnRange_build_EstWise3(mat,stopj,stopspecstate,startj,startspecstate)
1751 *
1752 * Descrip: This function calculates a single start/end set in linear space
1753 * Really a sub-routine for /AlnRangeSet_from_PackAln_EstWise3
1754 *
1755 *
1756 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
1757 * Arg: stopj [UNKN ] Undocumented argument [int]
1758 * Arg: stopspecstate [UNKN ] Undocumented argument [int]
1759 * Arg: startj [UNKN ] Undocumented argument [int *]
1760 * Arg: startspecstate [UNKN ] Undocumented argument [int *]
1761 *
1762 * Return [UNKN ] Undocumented return value [AlnRange *]
1763 *
1764 */
AlnRange_build_EstWise3(EstWise3 * mat,int stopj,int stopspecstate,int * startj,int * startspecstate)1765 AlnRange * AlnRange_build_EstWise3(EstWise3 * mat,int stopj,int stopspecstate,int * startj,int * startspecstate)
1766 {
1767 AlnRange * out;
1768 int jpos;
1769 int state;
1770
1771
1772 if( mat->basematrix->type != BASEMATRIX_TYPE_SHADOW) {
1773 warn("Bad error! - non shadow matrix type in AlnRangeSet_from_EstWise3");
1774 return NULL;
1775 }
1776
1777
1778 /* Assumme that we have specials (we should!). Read back along the specials till we have the finish point */
1779 if( read_special_strip_EstWise3(mat,0,stopj,stopspecstate,&jpos,&state,NULL) == FALSE) {
1780 warn("In AlnRanger_build_EstWise3 alignment ending at %d, unable to read back specials. Will (evenutally) return a partial range set... BEWARE!",stopj);
1781 return NULL;
1782 }
1783 if( state == START || jpos <= 0)
1784 return NULL;
1785
1786
1787 out = AlnRange_alloc();
1788
1789
1790 out->starti = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,0);
1791 out->startj = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,1);
1792 out->startstate = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,2);
1793 out->stopi = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,3);
1794 out->stopj = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,4);
1795 out->stopstate = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,5);
1796 out->startscore = EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,6);
1797 out->stopscore = EstWise3_DC_SHADOW_SPECIAL(mat,0,jpos,state);
1798
1799
1800 /* Now, we have to figure out where this state came from in the specials */
1801 max_matrix_to_special_EstWise3(mat,out->starti,out->startj,out->startstate,out->startscore,&jpos,startj,startspecstate,&state,NULL);
1802 if( jpos == EstWise3_READ_OFF_ERROR) {
1803 warn("In AlnRange_build_EstWise3 alignment ending at %d, with aln range between %d-%d in j, unable to find source special, returning this range, but this could get tricky!",stopj,out->startj,out->stopj);
1804 return out;
1805 }
1806
1807
1808 /* Put in the correct score for startstate, from the special */
1809 out->startscore = EstWise3_DC_SHADOW_SPECIAL(mat,0,*startj,*startspecstate);
1810 /* The correct j coords have been put into startj, startspecstate... so just return out */
1811 return out;
1812 }
1813
1814
1815 /* Function: read_hidden_EstWise3(mat,starti,startj,startstate,stopi,stopj,stopstate,out)
1816 *
1817 * Descrip: No Description
1818 *
1819 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
1820 * Arg: starti [UNKN ] Undocumented argument [int]
1821 * Arg: startj [UNKN ] Undocumented argument [int]
1822 * Arg: startstate [UNKN ] Undocumented argument [int]
1823 * Arg: stopi [UNKN ] Undocumented argument [int]
1824 * Arg: stopj [UNKN ] Undocumented argument [int]
1825 * Arg: stopstate [UNKN ] Undocumented argument [int]
1826 * Arg: out [UNKN ] Undocumented argument [PackAln *]
1827 *
1828 * Return [UNKN ] Undocumented return value [boolean]
1829 *
1830 */
read_hidden_EstWise3(EstWise3 * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,PackAln * out)1831 boolean read_hidden_EstWise3(EstWise3 * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,PackAln * out)
1832 {
1833 int i;
1834 int j;
1835 int state;
1836 int cellscore;
1837 int isspecial;
1838 /* We don't need hiddenj here, 'cause matrix access handled by max funcs */
1839 PackAlnUnit * pau;
1840
1841
1842 /* stop position is on the path */
1843 i = stopi;
1844 j = stopj;
1845 state= stopstate;
1846 isspecial = FALSE;
1847
1848
1849 while( i >= starti && j >= startj) {
1850 /* Put away current i,j,state */
1851 pau = PackAlnUnit_alloc();/* Should deal with memory overflow */
1852 pau->i = i;
1853 pau->j = j;
1854 pau->state = state;
1855 add_PackAln(out,pau);
1856
1857
1858 max_hidden_EstWise3(mat,startj,i,j,state,isspecial,&i,&j,&state,&isspecial,&cellscore);
1859
1860
1861 if( i == EstWise3_READ_OFF_ERROR) {
1862 warn("In EstWise3 hidden read off, between %d:%d,%d:%d - at got bad read off. Problem!",starti,startj,stopi,stopj);
1863 return FALSE;
1864 }
1865
1866
1867 if( i == starti && j == startj && state == startstate) {
1868 /* Put away final state (start of this block) */
1869 pau = PackAlnUnit_alloc(); /* Should deal with memory overflow */
1870 pau->i = i;
1871 pau->j = j;
1872 pau->state = state;
1873 add_PackAln(out,pau);
1874 return TRUE;
1875 }
1876 if( i == starti && j == startj) {
1877 warn("In EstWise3 hidden read off, between %d:%d,%d:%d - hit start cell, but not in start state. Can't be good!.",starti,startj,stopi,stopj);
1878 return FALSE;
1879 }
1880 }
1881 warn("In EstWise3 hidden read off, between %d:%d,%d:%d - gone past start cell (now in %d,%d,%d), can't be good news!.",starti,startj,stopi,stopj,i,j,state);
1882 return FALSE;
1883 }
1884
1885
1886 /* Function: max_hidden_EstWise3(mat,hiddenj,i,j,state,isspecial,reti,retj,retstate,retspecial,cellscore)
1887 *
1888 * Descrip: No Description
1889 *
1890 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
1891 * Arg: hiddenj [UNKN ] Undocumented argument [int]
1892 * Arg: i [UNKN ] Undocumented argument [int]
1893 * Arg: j [UNKN ] Undocumented argument [int]
1894 * Arg: state [UNKN ] Undocumented argument [int]
1895 * Arg: isspecial [UNKN ] Undocumented argument [boolean]
1896 * Arg: reti [UNKN ] Undocumented argument [int *]
1897 * Arg: retj [UNKN ] Undocumented argument [int *]
1898 * Arg: retstate [UNKN ] Undocumented argument [int *]
1899 * Arg: retspecial [UNKN ] Undocumented argument [boolean *]
1900 * Arg: cellscore [UNKN ] Undocumented argument [int *]
1901 *
1902 * Return [UNKN ] Undocumented return value [int]
1903 *
1904 */
max_hidden_EstWise3(EstWise3 * mat,int hiddenj,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)1905 int max_hidden_EstWise3(EstWise3 * mat,int hiddenj,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)
1906 {
1907 register int temp;
1908 register int cscore;
1909
1910
1911 *reti = (*retj) = (*retstate) = EstWise3_READ_OFF_ERROR;
1912
1913
1914 if( i < 0 || j < 0 || i > mat->query->len || j > mat->target->seq->len) {
1915 warn("In EstWise3 matrix special read off - out of bounds on matrix [i,j is %d,%d state %d in standard matrix]",i,j,state);
1916 return -1;
1917 }
1918
1919
1920 /* Then you have to select the correct switch statement to figure out the readoff */
1921 /* Somewhat odd - reverse the order of calculation and return as soon as it is correct */
1922 cscore = EstWise3_HIDDEN_MATRIX(mat,i,j,state);
1923 switch(state) { /*Switch state */
1924 case MATCH :
1925 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
1926 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 5,DELETE) ) {
1927 *reti = i - 1;
1928 *retj = j - 5;
1929 *retstate = DELETE;
1930 *retspecial = FALSE;
1931 if( cellscore != NULL) {
1932 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-5,DELETE);
1933 }
1934 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 5,DELETE);
1935 }
1936 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
1937 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 4,DELETE) ) {
1938 *reti = i - 1;
1939 *retj = j - 4;
1940 *retstate = DELETE;
1941 *retspecial = FALSE;
1942 if( cellscore != NULL) {
1943 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-4,DELETE);
1944 }
1945 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 4,DELETE);
1946 }
1947 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
1948 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 1,DELETE) ) {
1949 *reti = i - 1;
1950 *retj = j - 1;
1951 *retstate = DELETE;
1952 *retspecial = FALSE;
1953 if( cellscore != NULL) {
1954 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-1,DELETE);
1955 }
1956 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 1,DELETE);
1957 }
1958 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
1959 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 2,DELETE) ) {
1960 *reti = i - 1;
1961 *retj = j - 2;
1962 *retstate = DELETE;
1963 *retspecial = FALSE;
1964 if( cellscore != NULL) {
1965 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-2,DELETE);
1966 }
1967 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 2,DELETE);
1968 }
1969 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
1970 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 5,INSERT) ) {
1971 *reti = i - 1;
1972 *retj = j - 5;
1973 *retstate = INSERT;
1974 *retspecial = FALSE;
1975 if( cellscore != NULL) {
1976 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-5,INSERT);
1977 }
1978 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 5,INSERT);
1979 }
1980 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
1981 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 4,INSERT) ) {
1982 *reti = i - 1;
1983 *retj = j - 4;
1984 *retstate = INSERT;
1985 *retspecial = FALSE;
1986 if( cellscore != NULL) {
1987 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-4,INSERT);
1988 }
1989 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 4,INSERT);
1990 }
1991 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
1992 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 1,INSERT) ) {
1993 *reti = i - 1;
1994 *retj = j - 1;
1995 *retstate = INSERT;
1996 *retspecial = FALSE;
1997 if( cellscore != NULL) {
1998 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-1,INSERT);
1999 }
2000 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 1,INSERT);
2001 }
2002 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
2003 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 2,INSERT) ) {
2004 *reti = i - 1;
2005 *retj = j - 2;
2006 *retstate = INSERT;
2007 *retspecial = FALSE;
2008 if( cellscore != NULL) {
2009 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-2,INSERT);
2010 }
2011 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 2,INSERT);
2012 }
2013 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
2014 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 5,MATCH) ) {
2015 *reti = i - 1;
2016 *retj = j - 5;
2017 *retstate = MATCH;
2018 *retspecial = FALSE;
2019 if( cellscore != NULL) {
2020 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-5,MATCH);
2021 }
2022 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 5,MATCH);
2023 }
2024 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
2025 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 4,MATCH) ) {
2026 *reti = i - 1;
2027 *retj = j - 4;
2028 *retstate = MATCH;
2029 *retspecial = FALSE;
2030 if( cellscore != NULL) {
2031 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-4,MATCH);
2032 }
2033 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 4,MATCH);
2034 }
2035 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
2036 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 1,MATCH) ) {
2037 *reti = i - 1;
2038 *retj = j - 1;
2039 *retstate = MATCH;
2040 *retspecial = FALSE;
2041 if( cellscore != NULL) {
2042 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-1,MATCH);
2043 }
2044 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 1,MATCH);
2045 }
2046 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
2047 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 2,MATCH) ) {
2048 *reti = i - 1;
2049 *retj = j - 2;
2050 *retstate = MATCH;
2051 *retspecial = FALSE;
2052 if( cellscore != NULL) {
2053 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-2,MATCH);
2054 }
2055 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 2,MATCH);
2056 }
2057 /* Not allowing special sources.. skipping START */
2058 temp = cscore - ((mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
2059 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 3,DELETE) ) {
2060 *reti = i - 1;
2061 *retj = j - 3;
2062 *retstate = DELETE;
2063 *retspecial = FALSE;
2064 if( cellscore != NULL) {
2065 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-3,DELETE);
2066 }
2067 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 3,DELETE);
2068 }
2069 temp = cscore - ((mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
2070 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 3,INSERT) ) {
2071 *reti = i - 1;
2072 *retj = j - 3;
2073 *retstate = INSERT;
2074 *retspecial = FALSE;
2075 if( cellscore != NULL) {
2076 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-3,INSERT);
2077 }
2078 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 3,INSERT);
2079 }
2080 temp = cscore - ((mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
2081 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 3,MATCH) ) {
2082 *reti = i - 1;
2083 *retj = j - 3;
2084 *retstate = MATCH;
2085 *retspecial = FALSE;
2086 if( cellscore != NULL) {
2087 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-3,MATCH);
2088 }
2089 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 3,MATCH);
2090 }
2091 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
2092 return (-1);
2093 case INSERT :
2094 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
2095 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 5,DELETE) ) {
2096 *reti = i - 0;
2097 *retj = j - 5;
2098 *retstate = DELETE;
2099 *retspecial = FALSE;
2100 if( cellscore != NULL) {
2101 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-5,DELETE);
2102 }
2103 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 5,DELETE);
2104 }
2105 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
2106 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 4,DELETE) ) {
2107 *reti = i - 0;
2108 *retj = j - 4;
2109 *retstate = DELETE;
2110 *retspecial = FALSE;
2111 if( cellscore != NULL) {
2112 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-4,DELETE);
2113 }
2114 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 4,DELETE);
2115 }
2116 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
2117 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 1,DELETE) ) {
2118 *reti = i - 0;
2119 *retj = j - 1;
2120 *retstate = DELETE;
2121 *retspecial = FALSE;
2122 if( cellscore != NULL) {
2123 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-1,DELETE);
2124 }
2125 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 1,DELETE);
2126 }
2127 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
2128 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 2,DELETE) ) {
2129 *reti = i - 0;
2130 *retj = j - 2;
2131 *retstate = DELETE;
2132 *retspecial = FALSE;
2133 if( cellscore != NULL) {
2134 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-2,DELETE);
2135 }
2136 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 2,DELETE);
2137 }
2138 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
2139 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 5,MATCH) ) {
2140 *reti = i - 0;
2141 *retj = j - 5;
2142 *retstate = MATCH;
2143 *retspecial = FALSE;
2144 if( cellscore != NULL) {
2145 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-5,MATCH);
2146 }
2147 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 5,MATCH);
2148 }
2149 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
2150 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 4,MATCH) ) {
2151 *reti = i - 0;
2152 *retj = j - 4;
2153 *retstate = MATCH;
2154 *retspecial = FALSE;
2155 if( cellscore != NULL) {
2156 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-4,MATCH);
2157 }
2158 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 4,MATCH);
2159 }
2160 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
2161 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 1,MATCH) ) {
2162 *reti = i - 0;
2163 *retj = j - 1;
2164 *retstate = MATCH;
2165 *retspecial = FALSE;
2166 if( cellscore != NULL) {
2167 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-1,MATCH);
2168 }
2169 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 1,MATCH);
2170 }
2171 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
2172 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 2,MATCH) ) {
2173 *reti = i - 0;
2174 *retj = j - 2;
2175 *retstate = MATCH;
2176 *retspecial = FALSE;
2177 if( cellscore != NULL) {
2178 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-2,MATCH);
2179 }
2180 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 2,MATCH);
2181 }
2182 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
2183 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 5,INSERT) ) {
2184 *reti = i - 0;
2185 *retj = j - 5;
2186 *retstate = INSERT;
2187 *retspecial = FALSE;
2188 if( cellscore != NULL) {
2189 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-5,INSERT);
2190 }
2191 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 5,INSERT);
2192 }
2193 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
2194 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 4,INSERT) ) {
2195 *reti = i - 0;
2196 *retj = j - 4;
2197 *retstate = INSERT;
2198 *retspecial = FALSE;
2199 if( cellscore != NULL) {
2200 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-4,INSERT);
2201 }
2202 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 4,INSERT);
2203 }
2204 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
2205 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 1,INSERT) ) {
2206 *reti = i - 0;
2207 *retj = j - 1;
2208 *retstate = INSERT;
2209 *retspecial = FALSE;
2210 if( cellscore != NULL) {
2211 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-1,INSERT);
2212 }
2213 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 1,INSERT);
2214 }
2215 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
2216 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 2,INSERT) ) {
2217 *reti = i - 0;
2218 *retj = j - 2;
2219 *retstate = INSERT;
2220 *retspecial = FALSE;
2221 if( cellscore != NULL) {
2222 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-2,INSERT);
2223 }
2224 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 2,INSERT);
2225 }
2226 /* Not allowing special sources.. skipping START */
2227 temp = cscore - ((mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
2228 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 3,DELETE) ) {
2229 *reti = i - 0;
2230 *retj = j - 3;
2231 *retstate = DELETE;
2232 *retspecial = FALSE;
2233 if( cellscore != NULL) {
2234 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-3,DELETE);
2235 }
2236 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 3,DELETE);
2237 }
2238 temp = cscore - ((mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
2239 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 3,INSERT) ) {
2240 *reti = i - 0;
2241 *retj = j - 3;
2242 *retstate = INSERT;
2243 *retspecial = FALSE;
2244 if( cellscore != NULL) {
2245 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-3,INSERT);
2246 }
2247 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 3,INSERT);
2248 }
2249 temp = cscore - ((mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
2250 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 3,MATCH) ) {
2251 *reti = i - 0;
2252 *retj = j - 3;
2253 *retstate = MATCH;
2254 *retspecial = FALSE;
2255 if( cellscore != NULL) {
2256 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-0,j-3,MATCH);
2257 }
2258 return EstWise3_HIDDEN_MATRIX(mat,i - 0,j - 3,MATCH);
2259 }
2260 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
2261 return (-1);
2262 case DELETE :
2263 /* Not allowing special sources.. skipping START */
2264 temp = cscore - (mat->query->seg[i]->transition[GW_DELETE2DELETE]) - (0);
2265 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 0,DELETE) ) {
2266 *reti = i - 1;
2267 *retj = j - 0;
2268 *retstate = DELETE;
2269 *retspecial = FALSE;
2270 if( cellscore != NULL) {
2271 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-0,DELETE);
2272 }
2273 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 0,DELETE);
2274 }
2275 temp = cscore - (mat->query->seg[i]->transition[GW_INSERT2DELETE]) - (0);
2276 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 0,INSERT) ) {
2277 *reti = i - 1;
2278 *retj = j - 0;
2279 *retstate = INSERT;
2280 *retspecial = FALSE;
2281 if( cellscore != NULL) {
2282 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-0,INSERT);
2283 }
2284 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 0,INSERT);
2285 }
2286 temp = cscore - (mat->query->seg[i]->transition[GW_MATCH2DELETE]) - (0);
2287 if( temp == EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 0,MATCH) ) {
2288 *reti = i - 1;
2289 *retj = j - 0;
2290 *retstate = MATCH;
2291 *retspecial = FALSE;
2292 if( cellscore != NULL) {
2293 *cellscore = cscore - EstWise3_HIDDEN_MATRIX(mat,i-1,j-0,MATCH);
2294 }
2295 return EstWise3_HIDDEN_MATRIX(mat,i - 1,j - 0,MATCH);
2296 }
2297 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
2298 return (-1);
2299 default:
2300 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
2301 return (-1);
2302 } /* end of Switch state */
2303 }
2304
2305
2306 /* Function: read_special_strip_EstWise3(mat,stopi,stopj,stopstate,startj,startstate,out)
2307 *
2308 * Descrip: No Description
2309 *
2310 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
2311 * Arg: stopi [UNKN ] Undocumented argument [int]
2312 * Arg: stopj [UNKN ] Undocumented argument [int]
2313 * Arg: stopstate [UNKN ] Undocumented argument [int]
2314 * Arg: startj [UNKN ] Undocumented argument [int *]
2315 * Arg: startstate [UNKN ] Undocumented argument [int *]
2316 * Arg: out [UNKN ] Undocumented argument [PackAln *]
2317 *
2318 * Return [UNKN ] Undocumented return value [boolean]
2319 *
2320 */
read_special_strip_EstWise3(EstWise3 * mat,int stopi,int stopj,int stopstate,int * startj,int * startstate,PackAln * out)2321 boolean read_special_strip_EstWise3(EstWise3 * mat,int stopi,int stopj,int stopstate,int * startj,int * startstate,PackAln * out)
2322 {
2323 int i;
2324 int j;
2325 int state;
2326 int cellscore;
2327 int isspecial;
2328 PackAlnUnit * pau;
2329
2330
2331 /* stop position is on the path */
2332 i = stopi;
2333 j = stopj;
2334 state= stopstate;
2335 isspecial = TRUE;
2336
2337
2338 /* Loop until state has the same j as its stop in shadow pointers */
2339 /* This will be the state is came out from, OR it has hit !start */
2340 /* We may not want to get the alignment, in which case out will be NULL */
2341 while( j > EstWise3_DC_SHADOW_SPECIAL_SP(mat,i,j,state,4) && state != START) { /*while more specials to eat up*/
2342 /* Put away current state, if we should */
2343 if(out != NULL) {
2344 pau = PackAlnUnit_alloc(); /* Should deal with memory overflow */
2345 pau->i = i;
2346 pau->j = j;
2347 pau->state = state + 3;
2348 add_PackAln(out,pau);
2349 }
2350
2351
2352 max_special_strip_EstWise3(mat,i,j,state,isspecial,&i,&j,&state,&isspecial,&cellscore);
2353 if( i == EstWise3_READ_OFF_ERROR) {
2354 warn("In special strip read EstWise3, got a bad read off error. Sorry!");
2355 return FALSE;
2356 }
2357 } /* end of while more specials to eat up */
2358
2359
2360 /* check to see we have not gone too far! */
2361 if( state != START && j < EstWise3_DC_SHADOW_SPECIAL_SP(mat,i,j,state,4)) {
2362 warn("In special strip read EstWise3, at special [%d] state [%d] overshot!",j,state);
2363 return FALSE;
2364 }
2365 /* Put away last state */
2366 if(out != NULL) {
2367 pau = PackAlnUnit_alloc();/* Should deal with memory overflow */
2368 pau->i = i;
2369 pau->j = j;
2370 pau->state = state + 3;
2371 add_PackAln(out,pau);
2372 }
2373
2374
2375 /* Put away where we are in startj and startstate */
2376 *startj = j;
2377 *startstate = state;
2378 return TRUE;
2379 }
2380
2381
2382 /* Function: max_special_strip_EstWise3(mat,i,j,state,isspecial,reti,retj,retstate,retspecial,cellscore)
2383 *
2384 * Descrip: A pretty intense internal function. Deals with read-off only in specials
2385 *
2386 *
2387 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
2388 * Arg: i [UNKN ] Undocumented argument [int]
2389 * Arg: j [UNKN ] Undocumented argument [int]
2390 * Arg: state [UNKN ] Undocumented argument [int]
2391 * Arg: isspecial [UNKN ] Undocumented argument [boolean]
2392 * Arg: reti [UNKN ] Undocumented argument [int *]
2393 * Arg: retj [UNKN ] Undocumented argument [int *]
2394 * Arg: retstate [UNKN ] Undocumented argument [int *]
2395 * Arg: retspecial [UNKN ] Undocumented argument [boolean *]
2396 * Arg: cellscore [UNKN ] Undocumented argument [int *]
2397 *
2398 * Return [UNKN ] Undocumented return value [int]
2399 *
2400 */
max_special_strip_EstWise3(EstWise3 * mat,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)2401 int max_special_strip_EstWise3(EstWise3 * mat,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)
2402 {
2403 int temp;
2404 int cscore;
2405
2406
2407 *reti = (*retj) = (*retstate) = EstWise3_READ_OFF_ERROR;
2408 if( isspecial == FALSE ) {
2409 warn("In special strip max function for EstWise3, got a non special start point. Problem! (bad!)");
2410 return (-1);
2411 }
2412
2413
2414 if( j < 0 || j > mat->target->seq->len) {
2415 warn("In EstWise3 matrix special read off - out of bounds on matrix [j is %d in special]",j);
2416 return -1;
2417 }
2418
2419
2420 cscore = EstWise3_DC_SHADOW_SPECIAL(mat,i,j,state);
2421 switch(state) { /*switch on special states*/
2422 case START :
2423 case END :
2424 /* Source DELETE is not a special */
2425 /* Source INSERT is not a special */
2426 /* Source MATCH is not a special */
2427 default:
2428 warn("Major problem (!) - in EstWise3 special strip read off, position %d,%d state %d no source found dropped into default on source switch!",i,j,state);
2429 return (-1);
2430 } /* end of switch on special states */
2431 }
2432
2433
2434 /* Function: max_matrix_to_special_EstWise3(mat,i,j,state,cscore,reti,retj,retstate,retspecial,cellscore)
2435 *
2436 * Descrip: No Description
2437 *
2438 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
2439 * Arg: i [UNKN ] Undocumented argument [int]
2440 * Arg: j [UNKN ] Undocumented argument [int]
2441 * Arg: state [UNKN ] Undocumented argument [int]
2442 * Arg: cscore [UNKN ] Undocumented argument [int]
2443 * Arg: reti [UNKN ] Undocumented argument [int *]
2444 * Arg: retj [UNKN ] Undocumented argument [int *]
2445 * Arg: retstate [UNKN ] Undocumented argument [int *]
2446 * Arg: retspecial [UNKN ] Undocumented argument [boolean *]
2447 * Arg: cellscore [UNKN ] Undocumented argument [int *]
2448 *
2449 * Return [UNKN ] Undocumented return value [int]
2450 *
2451 */
max_matrix_to_special_EstWise3(EstWise3 * mat,int i,int j,int state,int cscore,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)2452 int max_matrix_to_special_EstWise3(EstWise3 * mat,int i,int j,int state,int cscore,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)
2453 {
2454 int temp;
2455 *reti = (*retj) = (*retstate) = EstWise3_READ_OFF_ERROR;
2456
2457
2458 if( j < 0 || j > mat->lenj) {
2459 warn("In EstWise3 matrix to special read off - out of bounds on matrix [j is %d in special]",j);
2460 return -1;
2461 }
2462
2463
2464 switch(state) { /*Switch state */
2465 case MATCH :
2466 /* Source DELETE is not a special, should not get here! */
2467 /* Source DELETE is not a special, should not get here! */
2468 /* Source DELETE is not a special, should not get here! */
2469 /* Source DELETE is not a special, should not get here! */
2470 /* Source INSERT is not a special, should not get here! */
2471 /* Source INSERT is not a special, should not get here! */
2472 /* Source INSERT is not a special, should not get here! */
2473 /* Source INSERT is not a special, should not get here! */
2474 /* Source MATCH is not a special, should not get here! */
2475 /* Source MATCH is not a special, should not get here! */
2476 /* Source MATCH is not a special, should not get here! */
2477 /* Source MATCH is not a special, should not get here! */
2478 temp = cscore - ((mat->query->seg[i]->transition[GW_START2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
2479 if( temp == EstWise3_DC_SHADOW_SPECIAL(mat,i - 1,j - 3,START) ) {
2480 *reti = i - 1;
2481 *retj = j - 3;
2482 *retstate = START;
2483 *retspecial = TRUE;
2484 if( cellscore != NULL) {
2485 *cellscore = cscore - EstWise3_DC_SHADOW_SPECIAL(mat,i-1,j-3,START);
2486 }
2487 return EstWise3_DC_SHADOW_MATRIX(mat,i - 1,j - 3,START) ;
2488 }
2489 /* Source DELETE is not a special, should not get here! */
2490 /* Source INSERT is not a special, should not get here! */
2491 /* Source MATCH is not a special, should not get here! */
2492 warn("Major problem (!) - in EstWise3 matrix to special read off, position %d,%d state %d no source found!",i,j,state);
2493 return (-1);
2494 case INSERT :
2495 /* Source DELETE is not a special, should not get here! */
2496 /* Source DELETE is not a special, should not get here! */
2497 /* Source DELETE is not a special, should not get here! */
2498 /* Source DELETE is not a special, should not get here! */
2499 /* Source MATCH is not a special, should not get here! */
2500 /* Source MATCH is not a special, should not get here! */
2501 /* Source MATCH is not a special, should not get here! */
2502 /* Source MATCH is not a special, should not get here! */
2503 /* Source INSERT is not a special, should not get here! */
2504 /* Source INSERT is not a special, should not get here! */
2505 /* Source INSERT is not a special, should not get here! */
2506 /* Source INSERT is not a special, should not get here! */
2507 temp = cscore - ((mat->query->seg[i]->transition[GW_START2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
2508 if( temp == EstWise3_DC_SHADOW_SPECIAL(mat,i - 0,j - 3,START) ) {
2509 *reti = i - 0;
2510 *retj = j - 3;
2511 *retstate = START;
2512 *retspecial = TRUE;
2513 if( cellscore != NULL) {
2514 *cellscore = cscore - EstWise3_DC_SHADOW_SPECIAL(mat,i-0,j-3,START);
2515 }
2516 return EstWise3_DC_SHADOW_MATRIX(mat,i - 0,j - 3,START) ;
2517 }
2518 /* Source DELETE is not a special, should not get here! */
2519 /* Source INSERT is not a special, should not get here! */
2520 /* Source MATCH is not a special, should not get here! */
2521 warn("Major problem (!) - in EstWise3 matrix to special read off, position %d,%d state %d no source found!",i,j,state);
2522 return (-1);
2523 case DELETE :
2524 temp = cscore - (mat->query->seg[i]->transition[GW_START2DELETE]) - (0);
2525 if( temp == EstWise3_DC_SHADOW_SPECIAL(mat,i - 1,j - 0,START) ) {
2526 *reti = i - 1;
2527 *retj = j - 0;
2528 *retstate = START;
2529 *retspecial = TRUE;
2530 if( cellscore != NULL) {
2531 *cellscore = cscore - EstWise3_DC_SHADOW_SPECIAL(mat,i-1,j-0,START);
2532 }
2533 return EstWise3_DC_SHADOW_MATRIX(mat,i - 1,j - 0,START) ;
2534 }
2535 /* Source DELETE is not a special, should not get here! */
2536 /* Source INSERT is not a special, should not get here! */
2537 /* Source MATCH is not a special, should not get here! */
2538 warn("Major problem (!) - in EstWise3 matrix to special read off, position %d,%d state %d no source found!",i,j,state);
2539 return (-1);
2540 default:
2541 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
2542 return (-1);
2543 } /* end of Switch state */
2544
2545
2546 }
2547
2548
2549 /* Function: calculate_hidden_EstWise3(mat,starti,startj,startstate,stopi,stopj,stopstate,dpenv)
2550 *
2551 * Descrip: No Description
2552 *
2553 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
2554 * Arg: starti [UNKN ] Undocumented argument [int]
2555 * Arg: startj [UNKN ] Undocumented argument [int]
2556 * Arg: startstate [UNKN ] Undocumented argument [int]
2557 * Arg: stopi [UNKN ] Undocumented argument [int]
2558 * Arg: stopj [UNKN ] Undocumented argument [int]
2559 * Arg: stopstate [UNKN ] Undocumented argument [int]
2560 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
2561 *
2562 */
calculate_hidden_EstWise3(EstWise3 * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,DPEnvelope * dpenv)2563 void calculate_hidden_EstWise3(EstWise3 * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,DPEnvelope * dpenv)
2564 {
2565 register int i;
2566 register int j;
2567 register int score;
2568 register int temp;
2569 register int hiddenj;
2570
2571
2572 hiddenj = startj;
2573
2574
2575 init_hidden_EstWise3(mat,starti,startj,stopi,stopj);
2576
2577
2578 EstWise3_HIDDEN_MATRIX(mat,starti,startj,startstate) = 0;
2579
2580
2581 for(j=startj;j<=stopj;j++) {
2582 for(i=starti;i<=stopi;i++) {
2583 /* Should *not* do very first cell as this is the one set to zero in one state! */
2584 if( i == starti && j == startj )
2585 continue;
2586 if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE ) { /*Is not in envelope*/
2587 EstWise3_HIDDEN_MATRIX(mat,i,j,MATCH) = NEGI;
2588 EstWise3_HIDDEN_MATRIX(mat,i,j,INSERT) = NEGI;
2589 EstWise3_HIDDEN_MATRIX(mat,i,j,DELETE) = NEGI;
2590 continue;
2591 } /* end of Is not in envelope */
2592
2593
2594 /* For state MATCH */
2595 /* setting first movement to score */
2596 score = EstWise3_HIDDEN_MATRIX(mat,i-1,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
2597 /* From state INSERT to state MATCH */
2598 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
2599 if( temp > score ) {
2600 score = temp;
2601 }
2602 /* From state DELETE to state MATCH */
2603 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
2604 if( temp > score ) {
2605 score = temp;
2606 }
2607 /* From state MATCH to state MATCH */
2608 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
2609 if( temp > score ) {
2610 score = temp;
2611 }
2612 /* From state MATCH to state MATCH */
2613 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
2614 if( temp > score ) {
2615 score = temp;
2616 }
2617 /* From state MATCH to state MATCH */
2618 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
2619 if( temp > score ) {
2620 score = temp;
2621 }
2622 /* From state MATCH to state MATCH */
2623 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
2624 if( temp > score ) {
2625 score = temp;
2626 }
2627 /* From state INSERT to state MATCH */
2628 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
2629 if( temp > score ) {
2630 score = temp;
2631 }
2632 /* From state INSERT to state MATCH */
2633 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
2634 if( temp > score ) {
2635 score = temp;
2636 }
2637 /* From state INSERT to state MATCH */
2638 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
2639 if( temp > score ) {
2640 score = temp;
2641 }
2642 /* From state INSERT to state MATCH */
2643 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
2644 if( temp > score ) {
2645 score = temp;
2646 }
2647 /* From state DELETE to state MATCH */
2648 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
2649 if( temp > score ) {
2650 score = temp;
2651 }
2652 /* From state DELETE to state MATCH */
2653 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
2654 if( temp > score ) {
2655 score = temp;
2656 }
2657 /* From state DELETE to state MATCH */
2658 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
2659 if( temp > score ) {
2660 score = temp;
2661 }
2662 /* From state DELETE to state MATCH */
2663 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
2664 if( temp > score ) {
2665 score = temp;
2666 }
2667
2668
2669 /* Ok - finished max calculation for MATCH */
2670 /* Add any movement independant score and put away */
2671 EstWise3_HIDDEN_MATRIX(mat,i,j,MATCH) = score;
2672 /* Finished calculating state MATCH */
2673
2674
2675 /* For state INSERT */
2676 /* setting first movement to score */
2677 score = EstWise3_HIDDEN_MATRIX(mat,i-0,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
2678 /* From state INSERT to state INSERT */
2679 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
2680 if( temp > score ) {
2681 score = temp;
2682 }
2683 /* From state DELETE to state INSERT */
2684 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
2685 if( temp > score ) {
2686 score = temp;
2687 }
2688 /* From state INSERT to state INSERT */
2689 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
2690 if( temp > score ) {
2691 score = temp;
2692 }
2693 /* From state INSERT to state INSERT */
2694 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
2695 if( temp > score ) {
2696 score = temp;
2697 }
2698 /* From state INSERT to state INSERT */
2699 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
2700 if( temp > score ) {
2701 score = temp;
2702 }
2703 /* From state INSERT to state INSERT */
2704 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
2705 if( temp > score ) {
2706 score = temp;
2707 }
2708 /* From state MATCH to state INSERT */
2709 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
2710 if( temp > score ) {
2711 score = temp;
2712 }
2713 /* From state MATCH to state INSERT */
2714 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
2715 if( temp > score ) {
2716 score = temp;
2717 }
2718 /* From state MATCH to state INSERT */
2719 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
2720 if( temp > score ) {
2721 score = temp;
2722 }
2723 /* From state MATCH to state INSERT */
2724 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
2725 if( temp > score ) {
2726 score = temp;
2727 }
2728 /* From state DELETE to state INSERT */
2729 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
2730 if( temp > score ) {
2731 score = temp;
2732 }
2733 /* From state DELETE to state INSERT */
2734 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
2735 if( temp > score ) {
2736 score = temp;
2737 }
2738 /* From state DELETE to state INSERT */
2739 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
2740 if( temp > score ) {
2741 score = temp;
2742 }
2743 /* From state DELETE to state INSERT */
2744 temp = EstWise3_HIDDEN_MATRIX(mat,i-0,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
2745 if( temp > score ) {
2746 score = temp;
2747 }
2748
2749
2750 /* Ok - finished max calculation for INSERT */
2751 /* Add any movement independant score and put away */
2752 EstWise3_HIDDEN_MATRIX(mat,i,j,INSERT) = score;
2753 /* Finished calculating state INSERT */
2754
2755
2756 /* For state DELETE */
2757 /* setting first movement to score */
2758 score = EstWise3_HIDDEN_MATRIX(mat,i-1,j-0,MATCH) + mat->query->seg[i]->transition[GW_MATCH2DELETE];
2759 /* From state INSERT to state DELETE */
2760 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-0,INSERT) + mat->query->seg[i]->transition[GW_INSERT2DELETE];
2761 if( temp > score ) {
2762 score = temp;
2763 }
2764 /* From state DELETE to state DELETE */
2765 temp = EstWise3_HIDDEN_MATRIX(mat,i-1,j-0,DELETE) + mat->query->seg[i]->transition[GW_DELETE2DELETE];
2766 if( temp > score ) {
2767 score = temp;
2768 }
2769
2770
2771 /* Ok - finished max calculation for DELETE */
2772 /* Add any movement independant score and put away */
2773 EstWise3_HIDDEN_MATRIX(mat,i,j,DELETE) = score;
2774 /* Finished calculating state DELETE */
2775 }
2776 }
2777
2778
2779 return;
2780 }
2781
2782
2783 /* Function: init_hidden_EstWise3(mat,starti,startj,stopi,stopj)
2784 *
2785 * Descrip: No Description
2786 *
2787 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
2788 * Arg: starti [UNKN ] Undocumented argument [int]
2789 * Arg: startj [UNKN ] Undocumented argument [int]
2790 * Arg: stopi [UNKN ] Undocumented argument [int]
2791 * Arg: stopj [UNKN ] Undocumented argument [int]
2792 *
2793 */
init_hidden_EstWise3(EstWise3 * mat,int starti,int startj,int stopi,int stopj)2794 void init_hidden_EstWise3(EstWise3 * mat,int starti,int startj,int stopi,int stopj)
2795 {
2796 register int i;
2797 register int j;
2798 register int hiddenj;
2799
2800
2801 hiddenj = startj;
2802 for(j=(startj-5);j<=stopj;j++) {
2803 for(i=(starti-1);i<=stopi;i++) {
2804 EstWise3_HIDDEN_MATRIX(mat,i,j,MATCH) = NEGI;
2805
2806 EstWise3_HIDDEN_MATRIX(mat,i,j,INSERT) = NEGI;
2807
2808 EstWise3_HIDDEN_MATRIX(mat,i,j,DELETE) = NEGI;
2809
2810 }
2811 }
2812
2813
2814 return;
2815 }
2816
2817
2818 /* Function: full_dc_EstWise3(mat,starti,startj,startstate,stopi,stopj,stopstate,out,donej,totalj,dpenv)
2819 *
2820 * Descrip: The main divide-and-conquor routine. Basically, call /PackAln_calculate_small_EstWise3
2821 * Not this function, which is pretty hard core.
2822 * Function is given start/end points (in main matrix) for alignment
2823 * It does some checks, decides whether start/end in j is small enough for explicit calc
2824 * - if yes, calculates it, reads off into PackAln (out), adds the j distance to donej and returns TRUE
2825 * - if no, uses /do_dc_single_pass_EstWise3 to get mid-point
2826 * saves midpoint, and calls itself to do right portion then left portion
2827 * right then left ensures PackAln is added the 'right' way, ie, back-to-front
2828 * returns FALSE on any error, with a warning
2829 *
2830 *
2831 * Arg: mat [UNKN ] Matrix with small memory implementation [EstWise3 *]
2832 * Arg: starti [UNKN ] Start position in i [int]
2833 * Arg: startj [UNKN ] Start position in j [int]
2834 * Arg: startstate [UNKN ] Start position state number [int]
2835 * Arg: stopi [UNKN ] Stop position in i [int]
2836 * Arg: stopj [UNKN ] Stop position in j [int]
2837 * Arg: stopstate [UNKN ] Stop position state number [int]
2838 * Arg: out [UNKN ] PackAln structure to put alignment into [PackAln *]
2839 * Arg: donej [UNKN ] pointer to a number with the amount of alignment done [int *]
2840 * Arg: totalj [UNKN ] total amount of alignment to do (in j coordinates) [int]
2841 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
2842 *
2843 * Return [UNKN ] Undocumented return value [boolean]
2844 *
2845 */
full_dc_EstWise3(EstWise3 * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,PackAln * out,int * donej,int totalj,DPEnvelope * dpenv)2846 boolean full_dc_EstWise3(EstWise3 * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,PackAln * out,int * donej,int totalj,DPEnvelope * dpenv)
2847 {
2848 int lstarti;
2849 int lstartj;
2850 int lstate;
2851
2852
2853 if( mat->basematrix->type != BASEMATRIX_TYPE_SHADOW) {
2854 warn("*Very* bad error! - non shadow matrix type in full_dc_EstWise3");
2855 return FALSE;
2856 }
2857
2858
2859 if( starti == -1 || startj == -1 || startstate == -1 || stopi == -1 || stopstate == -1) {
2860 warn("In full dc program, passed bad indices, indices passed were %d:%d[%d] to %d:%d[%d]\n",starti,startj,startstate,stopi,stopj,stopstate);
2861 return FALSE;
2862 }
2863
2864
2865 if( stopj - startj < 25) {
2866 log_full_error(REPORT,0,"[%d,%d][%d,%d] Explicit read off",starti,startj,stopi,stopj);/* Build hidden explicit matrix */
2867 calculate_hidden_EstWise3(mat,starti,startj,startstate,stopi,stopj,stopstate,dpenv);
2868 *donej += (stopj - startj); /* Now read it off into out */
2869 if( read_hidden_EstWise3(mat,starti,startj,startstate,stopi,stopj,stopstate,out) == FALSE) {
2870 warn("In full dc, at %d:%d,%d:%d got a bad hidden explicit read off... ",starti,startj,stopi,stopj);
2871 return FALSE;
2872 }
2873 return TRUE;
2874 }
2875
2876
2877 /* In actual divide and conquor */
2878 if( do_dc_single_pass_EstWise3(mat,starti,startj,startstate,stopi,stopj,stopstate,dpenv,(int)(*donej*100)/totalj) == FALSE) {
2879 warn("In divide and conquor for EstWise3, at bound %d:%d to %d:%d, unable to calculate midpoint. Problem!",starti,startj,stopi,stopj);
2880 return FALSE;
2881 }
2882
2883
2884 /* Ok... now we have to call on each side of the matrix */
2885 /* We have to retrieve left hand side positions, as they will be vapped by the time we call LHS */
2886 lstarti= EstWise3_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,0);
2887 lstartj= EstWise3_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,1);
2888 lstate = EstWise3_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,2);
2889
2890
2891 /* Call on right hand side: this lets us do the correct read off */
2892 if( full_dc_EstWise3(mat,EstWise3_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,3),EstWise3_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,4),EstWise3_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,5),stopi,stopj,stopstate,out,donej,totalj,dpenv) == FALSE) {
2893 /* Warning already issued, simply chained back up to top */
2894 return FALSE;
2895 }
2896 /* Call on left hand side */
2897 if( full_dc_EstWise3(mat,starti,startj,startstate,lstarti,lstartj,lstate,out,donej,totalj,dpenv) == FALSE) {
2898 /* Warning already issued, simply chained back up to top */
2899 return FALSE;
2900 }
2901
2902
2903 return TRUE;
2904 }
2905
2906
2907 /* Function: do_dc_single_pass_EstWise3(mat,starti,startj,startstate,stopi,stopj,stopstate,dpenv,perc_done)
2908 *
2909 * Descrip: No Description
2910 *
2911 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
2912 * Arg: starti [UNKN ] Undocumented argument [int]
2913 * Arg: startj [UNKN ] Undocumented argument [int]
2914 * Arg: startstate [UNKN ] Undocumented argument [int]
2915 * Arg: stopi [UNKN ] Undocumented argument [int]
2916 * Arg: stopj [UNKN ] Undocumented argument [int]
2917 * Arg: stopstate [UNKN ] Undocumented argument [int]
2918 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
2919 * Arg: perc_done [UNKN ] Undocumented argument [int]
2920 *
2921 * Return [UNKN ] Undocumented return value [boolean]
2922 *
2923 */
do_dc_single_pass_EstWise3(EstWise3 * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,DPEnvelope * dpenv,int perc_done)2924 boolean do_dc_single_pass_EstWise3(EstWise3 * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,DPEnvelope * dpenv,int perc_done)
2925 {
2926 int halfj;
2927 halfj = startj + ((stopj - startj)/2);
2928
2929
2930 init_dc_EstWise3(mat);
2931
2932
2933 EstWise3_DC_SHADOW_MATRIX(mat,starti,startj,startstate) = 0;
2934 run_up_dc_EstWise3(mat,starti,stopi,startj,halfj-1,dpenv,perc_done);
2935 push_dc_at_merge_EstWise3(mat,starti,stopi,halfj,&halfj,dpenv);
2936 follow_on_dc_EstWise3(mat,starti,stopi,halfj,stopj,dpenv,perc_done);
2937 return TRUE;
2938 }
2939
2940
2941 /* Function: push_dc_at_merge_EstWise3(mat,starti,stopi,startj,stopj,dpenv)
2942 *
2943 * Descrip: No Description
2944 *
2945 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
2946 * Arg: starti [UNKN ] Undocumented argument [int]
2947 * Arg: stopi [UNKN ] Undocumented argument [int]
2948 * Arg: startj [UNKN ] Undocumented argument [int]
2949 * Arg: stopj [UNKN ] Undocumented argument [int *]
2950 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
2951 *
2952 */
push_dc_at_merge_EstWise3(EstWise3 * mat,int starti,int stopi,int startj,int * stopj,DPEnvelope * dpenv)2953 void push_dc_at_merge_EstWise3(EstWise3 * mat,int starti,int stopi,int startj,int * stopj,DPEnvelope * dpenv)
2954 {
2955 register int i;
2956 register int j;
2957 register int k;
2958 register int count;
2959 register int mergej;/* Sources below this j will be stamped by triples */
2960 register int score;
2961 register int temp;
2962
2963
2964 mergej = startj -1;
2965 for(count=0,j=startj;count<5;count++,j++) {
2966 for(i=starti;i<=stopi;i++) {
2967 if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE ) { /*Is not in envelope*/
2968 EstWise3_DC_SHADOW_MATRIX(mat,i,j,MATCH) = NEGI;
2969 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = (-100);
2970 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = (-100);
2971 EstWise3_DC_SHADOW_MATRIX(mat,i,j,INSERT) = NEGI;
2972 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = (-100);
2973 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = (-100);
2974 EstWise3_DC_SHADOW_MATRIX(mat,i,j,DELETE) = NEGI;
2975 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,0) = (-100);
2976 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,1) = (-100);
2977 continue;
2978 } /* end of Is not in envelope */
2979
2980
2981 /* For state MATCH, pushing when j - offj <= mergej */
2982 score = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
2983 if( j - 3 <= mergej) {
2984 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
2985 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-3;
2986 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = MATCH;
2987 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
2988 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
2989 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
2990 }
2991 else {
2992 for(k=0;k<7;k++)
2993 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 3,MATCH,k);
2994 }
2995
2996
2997 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
2998 if( temp > score) {
2999 score = temp;
3000
3001
3002 if( j - 3 <= mergej) {
3003 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3004 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-3;
3005 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = INSERT;
3006 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3007 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3008 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3009 }
3010 else {
3011 for(k=0;k<7;k++)
3012 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 3,INSERT,k);
3013 }
3014 }
3015
3016
3017 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
3018 if( temp > score) {
3019 score = temp;
3020
3021
3022 if( j - 3 <= mergej) {
3023 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3024 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-3;
3025 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = DELETE;
3026 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3027 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3028 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3029 }
3030 else {
3031 for(k=0;k<7;k++)
3032 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 3,DELETE,k);
3033 }
3034 }
3035
3036
3037 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
3038 if( temp > score) {
3039 score = temp;
3040
3041
3042 if( j - 2 <= mergej) {
3043 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3044 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-2;
3045 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = MATCH;
3046 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3047 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3048 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3049 }
3050 else {
3051 for(k=0;k<7;k++)
3052 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 2,MATCH,k);
3053 }
3054 }
3055
3056
3057 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
3058 if( temp > score) {
3059 score = temp;
3060
3061
3062 if( j - 1 <= mergej) {
3063 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3064 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-1;
3065 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = MATCH;
3066 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3067 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3068 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3069 }
3070 else {
3071 for(k=0;k<7;k++)
3072 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 1,MATCH,k);
3073 }
3074 }
3075
3076
3077 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
3078 if( temp > score) {
3079 score = temp;
3080
3081
3082 if( j - 4 <= mergej) {
3083 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3084 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-4;
3085 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = MATCH;
3086 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3087 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3088 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3089 }
3090 else {
3091 for(k=0;k<7;k++)
3092 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 4,MATCH,k);
3093 }
3094 }
3095
3096
3097 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
3098 if( temp > score) {
3099 score = temp;
3100
3101
3102 if( j - 5 <= mergej) {
3103 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3104 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-5;
3105 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = MATCH;
3106 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3107 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3108 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3109 }
3110 else {
3111 for(k=0;k<7;k++)
3112 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 5,MATCH,k);
3113 }
3114 }
3115
3116
3117 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
3118 if( temp > score) {
3119 score = temp;
3120
3121
3122 if( j - 2 <= mergej) {
3123 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3124 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-2;
3125 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = INSERT;
3126 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3127 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3128 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3129 }
3130 else {
3131 for(k=0;k<7;k++)
3132 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 2,INSERT,k);
3133 }
3134 }
3135
3136
3137 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
3138 if( temp > score) {
3139 score = temp;
3140
3141
3142 if( j - 1 <= mergej) {
3143 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3144 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-1;
3145 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = INSERT;
3146 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3147 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3148 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3149 }
3150 else {
3151 for(k=0;k<7;k++)
3152 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 1,INSERT,k);
3153 }
3154 }
3155
3156
3157 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
3158 if( temp > score) {
3159 score = temp;
3160
3161
3162 if( j - 4 <= mergej) {
3163 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3164 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-4;
3165 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = INSERT;
3166 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3167 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3168 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3169 }
3170 else {
3171 for(k=0;k<7;k++)
3172 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 4,INSERT,k);
3173 }
3174 }
3175
3176
3177 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
3178 if( temp > score) {
3179 score = temp;
3180
3181
3182 if( j - 5 <= mergej) {
3183 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3184 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-5;
3185 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = INSERT;
3186 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3187 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3188 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3189 }
3190 else {
3191 for(k=0;k<7;k++)
3192 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 5,INSERT,k);
3193 }
3194 }
3195
3196
3197 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
3198 if( temp > score) {
3199 score = temp;
3200
3201
3202 if( j - 2 <= mergej) {
3203 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3204 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-2;
3205 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = DELETE;
3206 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3207 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3208 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3209 }
3210 else {
3211 for(k=0;k<7;k++)
3212 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 2,DELETE,k);
3213 }
3214 }
3215
3216
3217 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
3218 if( temp > score) {
3219 score = temp;
3220
3221
3222 if( j - 1 <= mergej) {
3223 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3224 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-1;
3225 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = DELETE;
3226 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3227 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3228 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3229 }
3230 else {
3231 for(k=0;k<7;k++)
3232 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 1,DELETE,k);
3233 }
3234 }
3235
3236
3237 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
3238 if( temp > score) {
3239 score = temp;
3240
3241
3242 if( j - 4 <= mergej) {
3243 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3244 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-4;
3245 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = DELETE;
3246 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3247 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3248 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3249 }
3250 else {
3251 for(k=0;k<7;k++)
3252 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 4,DELETE,k);
3253 }
3254 }
3255
3256
3257 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
3258 if( temp > score) {
3259 score = temp;
3260
3261
3262 if( j - 5 <= mergej) {
3263 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = i-1;
3264 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,1) = j-5;
3265 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,2) = DELETE;
3266 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,3) = i;
3267 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,4) = j;
3268 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,5) = MATCH;
3269 }
3270 else {
3271 for(k=0;k<7;k++)
3272 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 5,DELETE,k);
3273 }
3274 }
3275 /* Add any movement independant score */
3276 EstWise3_DC_SHADOW_MATRIX(mat,i,j,MATCH) = score;
3277 /* Finished with state MATCH */
3278
3279
3280 /* For state INSERT, pushing when j - offj <= mergej */
3281 score = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
3282 if( j - 3 <= mergej) {
3283 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3284 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-3;
3285 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = MATCH;
3286 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3287 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3288 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3289 }
3290 else {
3291 for(k=0;k<7;k++)
3292 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 3,MATCH,k);
3293 }
3294
3295
3296 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
3297 if( temp > score) {
3298 score = temp;
3299
3300
3301 if( j - 3 <= mergej) {
3302 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3303 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-3;
3304 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = INSERT;
3305 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3306 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3307 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3308 }
3309 else {
3310 for(k=0;k<7;k++)
3311 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 3,INSERT,k);
3312 }
3313 }
3314
3315
3316 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
3317 if( temp > score) {
3318 score = temp;
3319
3320
3321 if( j - 3 <= mergej) {
3322 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3323 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-3;
3324 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = DELETE;
3325 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3326 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3327 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3328 }
3329 else {
3330 for(k=0;k<7;k++)
3331 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 3,DELETE,k);
3332 }
3333 }
3334
3335
3336 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
3337 if( temp > score) {
3338 score = temp;
3339
3340
3341 if( j - 2 <= mergej) {
3342 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3343 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-2;
3344 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = INSERT;
3345 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3346 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3347 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3348 }
3349 else {
3350 for(k=0;k<7;k++)
3351 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 2,INSERT,k);
3352 }
3353 }
3354
3355
3356 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
3357 if( temp > score) {
3358 score = temp;
3359
3360
3361 if( j - 1 <= mergej) {
3362 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3363 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-1;
3364 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = INSERT;
3365 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3366 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3367 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3368 }
3369 else {
3370 for(k=0;k<7;k++)
3371 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 1,INSERT,k);
3372 }
3373 }
3374
3375
3376 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
3377 if( temp > score) {
3378 score = temp;
3379
3380
3381 if( j - 4 <= mergej) {
3382 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3383 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-4;
3384 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = INSERT;
3385 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3386 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3387 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3388 }
3389 else {
3390 for(k=0;k<7;k++)
3391 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 4,INSERT,k);
3392 }
3393 }
3394
3395
3396 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
3397 if( temp > score) {
3398 score = temp;
3399
3400
3401 if( j - 5 <= mergej) {
3402 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3403 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-5;
3404 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = INSERT;
3405 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3406 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3407 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3408 }
3409 else {
3410 for(k=0;k<7;k++)
3411 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 5,INSERT,k);
3412 }
3413 }
3414
3415
3416 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
3417 if( temp > score) {
3418 score = temp;
3419
3420
3421 if( j - 2 <= mergej) {
3422 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3423 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-2;
3424 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = MATCH;
3425 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3426 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3427 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3428 }
3429 else {
3430 for(k=0;k<7;k++)
3431 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 2,MATCH,k);
3432 }
3433 }
3434
3435
3436 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
3437 if( temp > score) {
3438 score = temp;
3439
3440
3441 if( j - 1 <= mergej) {
3442 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3443 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-1;
3444 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = MATCH;
3445 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3446 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3447 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3448 }
3449 else {
3450 for(k=0;k<7;k++)
3451 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 1,MATCH,k);
3452 }
3453 }
3454
3455
3456 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
3457 if( temp > score) {
3458 score = temp;
3459
3460
3461 if( j - 4 <= mergej) {
3462 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3463 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-4;
3464 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = MATCH;
3465 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3466 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3467 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3468 }
3469 else {
3470 for(k=0;k<7;k++)
3471 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 4,MATCH,k);
3472 }
3473 }
3474
3475
3476 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
3477 if( temp > score) {
3478 score = temp;
3479
3480
3481 if( j - 5 <= mergej) {
3482 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3483 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-5;
3484 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = MATCH;
3485 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3486 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3487 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3488 }
3489 else {
3490 for(k=0;k<7;k++)
3491 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 5,MATCH,k);
3492 }
3493 }
3494
3495
3496 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
3497 if( temp > score) {
3498 score = temp;
3499
3500
3501 if( j - 2 <= mergej) {
3502 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3503 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-2;
3504 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = DELETE;
3505 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3506 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3507 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3508 }
3509 else {
3510 for(k=0;k<7;k++)
3511 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 2,DELETE,k);
3512 }
3513 }
3514
3515
3516 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
3517 if( temp > score) {
3518 score = temp;
3519
3520
3521 if( j - 1 <= mergej) {
3522 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3523 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-1;
3524 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = DELETE;
3525 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3526 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3527 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3528 }
3529 else {
3530 for(k=0;k<7;k++)
3531 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 1,DELETE,k);
3532 }
3533 }
3534
3535
3536 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
3537 if( temp > score) {
3538 score = temp;
3539
3540
3541 if( j - 4 <= mergej) {
3542 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3543 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-4;
3544 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = DELETE;
3545 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3546 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3547 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3548 }
3549 else {
3550 for(k=0;k<7;k++)
3551 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 4,DELETE,k);
3552 }
3553 }
3554
3555
3556 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
3557 if( temp > score) {
3558 score = temp;
3559
3560
3561 if( j - 5 <= mergej) {
3562 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = i-0;
3563 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,1) = j-5;
3564 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,2) = DELETE;
3565 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,3) = i;
3566 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,4) = j;
3567 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,5) = INSERT;
3568 }
3569 else {
3570 for(k=0;k<7;k++)
3571 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 5,DELETE,k);
3572 }
3573 }
3574 /* Add any movement independant score */
3575 EstWise3_DC_SHADOW_MATRIX(mat,i,j,INSERT) = score;
3576 /* Finished with state INSERT */
3577
3578
3579 /* For state DELETE, pushing when j - offj <= mergej */
3580 score = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,MATCH) + mat->query->seg[i]->transition[GW_MATCH2DELETE];
3581 if( j - 0 <= mergej) {
3582 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,0) = i-1;
3583 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,1) = j-0;
3584 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,2) = MATCH;
3585 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,3) = i;
3586 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,4) = j;
3587 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,5) = DELETE;
3588 }
3589 else {
3590 for(k=0;k<7;k++)
3591 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 0,MATCH,k);
3592 }
3593
3594
3595 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,INSERT) + mat->query->seg[i]->transition[GW_INSERT2DELETE];
3596 if( temp > score) {
3597 score = temp;
3598
3599
3600 if( j - 0 <= mergej) {
3601 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,0) = i-1;
3602 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,1) = j-0;
3603 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,2) = INSERT;
3604 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,3) = i;
3605 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,4) = j;
3606 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,5) = DELETE;
3607 }
3608 else {
3609 for(k=0;k<7;k++)
3610 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 0,INSERT,k);
3611 }
3612 }
3613
3614
3615 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,DELETE) + mat->query->seg[i]->transition[GW_DELETE2DELETE];
3616 if( temp > score) {
3617 score = temp;
3618
3619
3620 if( j - 0 <= mergej) {
3621 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,0) = i-1;
3622 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,1) = j-0;
3623 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,2) = DELETE;
3624 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,3) = i;
3625 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,4) = j;
3626 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,5) = DELETE;
3627 }
3628 else {
3629 for(k=0;k<7;k++)
3630 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,k) = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 0,DELETE,k);
3631 }
3632 }
3633 /* Add any movement independant score */
3634 EstWise3_DC_SHADOW_MATRIX(mat,i,j,DELETE) = score;
3635 /* Finished with state DELETE */
3636 }
3637 }
3638 /* Put back j into * stop j so that calling function gets it correct */
3639 if( stopj == NULL)
3640 warn("Bad news... NULL stopj pointer in push dc function. This means that calling function does not know how many cells I have done!");
3641 else
3642 *stopj = j;
3643
3644
3645 return;
3646 }
3647
3648
3649 /* Function: follow_on_dc_EstWise3(mat,starti,stopi,startj,stopj,dpenv,perc_done)
3650 *
3651 * Descrip: No Description
3652 *
3653 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
3654 * Arg: starti [UNKN ] Undocumented argument [int]
3655 * Arg: stopi [UNKN ] Undocumented argument [int]
3656 * Arg: startj [UNKN ] Undocumented argument [int]
3657 * Arg: stopj [UNKN ] Undocumented argument [int]
3658 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
3659 * Arg: perc_done [UNKN ] Undocumented argument [int]
3660 *
3661 */
follow_on_dc_EstWise3(EstWise3 * mat,int starti,int stopi,int startj,int stopj,DPEnvelope * dpenv,int perc_done)3662 void follow_on_dc_EstWise3(EstWise3 * mat,int starti,int stopi,int startj,int stopj,DPEnvelope * dpenv,int perc_done)
3663 {
3664 int i;
3665 int j;
3666 int k;
3667 int score;
3668 int temp;
3669 int localshadow[7];
3670 long int total;
3671 long int num;
3672
3673
3674 total = (stopi - starti+1) * (stopj - startj+1);
3675 num = 0;
3676
3677
3678 for(j=startj;j<=stopj;j++) { /*for each valid j column*/
3679 for(i=starti;i<=stopi;i++) { /*this is strip*/
3680 num++;
3681 if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE ) { /*Is not in envelope*/
3682 EstWise3_DC_SHADOW_MATRIX(mat,i,j,MATCH) = NEGI;
3683 EstWise3_DC_SHADOW_MATRIX(mat,i,j,INSERT) = NEGI;
3684 EstWise3_DC_SHADOW_MATRIX(mat,i,j,DELETE) = NEGI;
3685 continue;
3686 } /* end of Is not in envelope */
3687 if( num % 1000 == 0 )
3688 log_full_error(REPORT,0,"[%d%%%% done]After mid-j %5d Cells done %d%%%%",perc_done,startj,(num*100)/total);
3689
3690
3691 /* For state MATCH */
3692 /* setting first movement to score */
3693 score = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
3694 /* shift first shadow numbers */
3695 for(k=0;k<7;k++)
3696 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 3,MATCH,k);
3697 /* From state INSERT to state MATCH */
3698 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
3699 if( temp > score ) {
3700 score = temp;
3701 for(k=0;k<7;k++)
3702 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 3,INSERT,k);
3703 }
3704 /* From state DELETE to state MATCH */
3705 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
3706 if( temp > score ) {
3707 score = temp;
3708 for(k=0;k<7;k++)
3709 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 3,DELETE,k);
3710 }
3711 /* From state MATCH to state MATCH */
3712 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
3713 if( temp > score ) {
3714 score = temp;
3715 for(k=0;k<7;k++)
3716 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 2,MATCH,k);
3717 }
3718 /* From state MATCH to state MATCH */
3719 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
3720 if( temp > score ) {
3721 score = temp;
3722 for(k=0;k<7;k++)
3723 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 1,MATCH,k);
3724 }
3725 /* From state MATCH to state MATCH */
3726 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
3727 if( temp > score ) {
3728 score = temp;
3729 for(k=0;k<7;k++)
3730 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 4,MATCH,k);
3731 }
3732 /* From state MATCH to state MATCH */
3733 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
3734 if( temp > score ) {
3735 score = temp;
3736 for(k=0;k<7;k++)
3737 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 5,MATCH,k);
3738 }
3739 /* From state INSERT to state MATCH */
3740 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
3741 if( temp > score ) {
3742 score = temp;
3743 for(k=0;k<7;k++)
3744 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 2,INSERT,k);
3745 }
3746 /* From state INSERT to state MATCH */
3747 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
3748 if( temp > score ) {
3749 score = temp;
3750 for(k=0;k<7;k++)
3751 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 1,INSERT,k);
3752 }
3753 /* From state INSERT to state MATCH */
3754 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
3755 if( temp > score ) {
3756 score = temp;
3757 for(k=0;k<7;k++)
3758 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 4,INSERT,k);
3759 }
3760 /* From state INSERT to state MATCH */
3761 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
3762 if( temp > score ) {
3763 score = temp;
3764 for(k=0;k<7;k++)
3765 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 5,INSERT,k);
3766 }
3767 /* From state DELETE to state MATCH */
3768 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
3769 if( temp > score ) {
3770 score = temp;
3771 for(k=0;k<7;k++)
3772 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 2,DELETE,k);
3773 }
3774 /* From state DELETE to state MATCH */
3775 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
3776 if( temp > score ) {
3777 score = temp;
3778 for(k=0;k<7;k++)
3779 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 1,DELETE,k);
3780 }
3781 /* From state DELETE to state MATCH */
3782 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
3783 if( temp > score ) {
3784 score = temp;
3785 for(k=0;k<7;k++)
3786 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 4,DELETE,k);
3787 }
3788 /* From state DELETE to state MATCH */
3789 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
3790 if( temp > score ) {
3791 score = temp;
3792 for(k=0;k<7;k++)
3793 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 5,DELETE,k);
3794 }
3795
3796
3797 /* Ok - finished max calculation for MATCH */
3798 /* Add any movement independant score and put away */
3799 EstWise3_DC_SHADOW_MATRIX(mat,i,j,MATCH) = score;
3800 for(k=0;k<7;k++)
3801 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = localshadow[k];
3802 /* Now figure out if any specials need this score */
3803 /* Finished calculating state MATCH */
3804
3805
3806 /* For state INSERT */
3807 /* setting first movement to score */
3808 score = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
3809 /* shift first shadow numbers */
3810 for(k=0;k<7;k++)
3811 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 3,MATCH,k);
3812 /* From state INSERT to state INSERT */
3813 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
3814 if( temp > score ) {
3815 score = temp;
3816 for(k=0;k<7;k++)
3817 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 3,INSERT,k);
3818 }
3819 /* From state DELETE to state INSERT */
3820 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
3821 if( temp > score ) {
3822 score = temp;
3823 for(k=0;k<7;k++)
3824 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 3,DELETE,k);
3825 }
3826 /* From state INSERT to state INSERT */
3827 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
3828 if( temp > score ) {
3829 score = temp;
3830 for(k=0;k<7;k++)
3831 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 2,INSERT,k);
3832 }
3833 /* From state INSERT to state INSERT */
3834 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
3835 if( temp > score ) {
3836 score = temp;
3837 for(k=0;k<7;k++)
3838 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 1,INSERT,k);
3839 }
3840 /* From state INSERT to state INSERT */
3841 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
3842 if( temp > score ) {
3843 score = temp;
3844 for(k=0;k<7;k++)
3845 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 4,INSERT,k);
3846 }
3847 /* From state INSERT to state INSERT */
3848 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
3849 if( temp > score ) {
3850 score = temp;
3851 for(k=0;k<7;k++)
3852 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 5,INSERT,k);
3853 }
3854 /* From state MATCH to state INSERT */
3855 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
3856 if( temp > score ) {
3857 score = temp;
3858 for(k=0;k<7;k++)
3859 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 2,MATCH,k);
3860 }
3861 /* From state MATCH to state INSERT */
3862 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
3863 if( temp > score ) {
3864 score = temp;
3865 for(k=0;k<7;k++)
3866 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 1,MATCH,k);
3867 }
3868 /* From state MATCH to state INSERT */
3869 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
3870 if( temp > score ) {
3871 score = temp;
3872 for(k=0;k<7;k++)
3873 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 4,MATCH,k);
3874 }
3875 /* From state MATCH to state INSERT */
3876 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
3877 if( temp > score ) {
3878 score = temp;
3879 for(k=0;k<7;k++)
3880 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 5,MATCH,k);
3881 }
3882 /* From state DELETE to state INSERT */
3883 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
3884 if( temp > score ) {
3885 score = temp;
3886 for(k=0;k<7;k++)
3887 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 2,DELETE,k);
3888 }
3889 /* From state DELETE to state INSERT */
3890 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
3891 if( temp > score ) {
3892 score = temp;
3893 for(k=0;k<7;k++)
3894 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 1,DELETE,k);
3895 }
3896 /* From state DELETE to state INSERT */
3897 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
3898 if( temp > score ) {
3899 score = temp;
3900 for(k=0;k<7;k++)
3901 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 4,DELETE,k);
3902 }
3903 /* From state DELETE to state INSERT */
3904 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
3905 if( temp > score ) {
3906 score = temp;
3907 for(k=0;k<7;k++)
3908 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 0,j - 5,DELETE,k);
3909 }
3910
3911
3912 /* Ok - finished max calculation for INSERT */
3913 /* Add any movement independant score and put away */
3914 EstWise3_DC_SHADOW_MATRIX(mat,i,j,INSERT) = score;
3915 for(k=0;k<7;k++)
3916 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = localshadow[k];
3917 /* Now figure out if any specials need this score */
3918 /* Finished calculating state INSERT */
3919
3920
3921 /* For state DELETE */
3922 /* setting first movement to score */
3923 score = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,MATCH) + mat->query->seg[i]->transition[GW_MATCH2DELETE];
3924 /* shift first shadow numbers */
3925 for(k=0;k<7;k++)
3926 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 0,MATCH,k);
3927 /* From state INSERT to state DELETE */
3928 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,INSERT) + mat->query->seg[i]->transition[GW_INSERT2DELETE];
3929 if( temp > score ) {
3930 score = temp;
3931 for(k=0;k<7;k++)
3932 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 0,INSERT,k);
3933 }
3934 /* From state DELETE to state DELETE */
3935 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,DELETE) + mat->query->seg[i]->transition[GW_DELETE2DELETE];
3936 if( temp > score ) {
3937 score = temp;
3938 for(k=0;k<7;k++)
3939 localshadow[k] = EstWise3_DC_SHADOW_MATRIX_SP(mat,i - 1,j - 0,DELETE,k);
3940 }
3941
3942
3943 /* Ok - finished max calculation for DELETE */
3944 /* Add any movement independant score and put away */
3945 EstWise3_DC_SHADOW_MATRIX(mat,i,j,DELETE) = score;
3946 for(k=0;k<7;k++)
3947 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,k) = localshadow[k];
3948 /* Now figure out if any specials need this score */
3949 /* Finished calculating state DELETE */
3950 } /* end of this is strip */
3951 } /* end of for each valid j column */
3952
3953
3954 /* Function: run_up_dc_EstWise3(mat,starti,stopi,startj,stopj,dpenv,perc_done)
3955 *
3956 * Descrip: No Description
3957 *
3958 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
3959 * Arg: starti [UNKN ] Undocumented argument [int]
3960 * Arg: stopi [UNKN ] Undocumented argument [int]
3961 * Arg: startj [UNKN ] Undocumented argument [int]
3962 * Arg: stopj [UNKN ] Undocumented argument [int]
3963 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
3964 * Arg: perc_done [UNKN ] Undocumented argument [int]
3965 *
3966 */
3967 }
run_up_dc_EstWise3(EstWise3 * mat,int starti,int stopi,int startj,int stopj,DPEnvelope * dpenv,int perc_done)3968 void run_up_dc_EstWise3(EstWise3 * mat,int starti,int stopi,int startj,int stopj,DPEnvelope * dpenv,int perc_done)
3969 {
3970 register int i;
3971 register int j;
3972 register int score;
3973 register int temp;
3974 long int total;
3975 long int num;
3976
3977
3978 total = (stopi - starti+1) * (stopj - startj+1);
3979 if( total <= 0 )
3980 total = 1;
3981 num = 0;
3982
3983
3984 for(j=startj;j<=stopj;j++) { /*for each valid j column*/
3985 for(i=starti;i<=stopi;i++) { /*this is strip*/
3986 if( j == startj && i == starti)
3987 continue;
3988 num++;
3989 if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE ) { /*Is not in envelope*/
3990 EstWise3_DC_SHADOW_MATRIX(mat,i,j,MATCH) = NEGI;
3991 EstWise3_DC_SHADOW_MATRIX(mat,i,j,INSERT) = NEGI;
3992 EstWise3_DC_SHADOW_MATRIX(mat,i,j,DELETE) = NEGI;
3993 continue;
3994 } /* end of Is not in envelope */
3995 if( num % 1000 == 0 )
3996 log_full_error(REPORT,0,"[%d%%%% done]Before mid-j %5d Cells done %d%%%%",perc_done,stopj,(num*100)/total);
3997
3998
3999 /* For state MATCH */
4000 /* setting first movement to score */
4001 score = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
4002 /* From state INSERT to state MATCH */
4003 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
4004 if( temp > score ) {
4005 score = temp;
4006 }
4007 /* From state DELETE to state MATCH */
4008 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
4009 if( temp > score ) {
4010 score = temp;
4011 }
4012 /* From state MATCH to state MATCH */
4013 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
4014 if( temp > score ) {
4015 score = temp;
4016 }
4017 /* From state MATCH to state MATCH */
4018 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
4019 if( temp > score ) {
4020 score = temp;
4021 }
4022 /* From state MATCH to state MATCH */
4023 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
4024 if( temp > score ) {
4025 score = temp;
4026 }
4027 /* From state MATCH to state MATCH */
4028 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
4029 if( temp > score ) {
4030 score = temp;
4031 }
4032 /* From state INSERT to state MATCH */
4033 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
4034 if( temp > score ) {
4035 score = temp;
4036 }
4037 /* From state INSERT to state MATCH */
4038 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
4039 if( temp > score ) {
4040 score = temp;
4041 }
4042 /* From state INSERT to state MATCH */
4043 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
4044 if( temp > score ) {
4045 score = temp;
4046 }
4047 /* From state INSERT to state MATCH */
4048 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
4049 if( temp > score ) {
4050 score = temp;
4051 }
4052 /* From state DELETE to state MATCH */
4053 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
4054 if( temp > score ) {
4055 score = temp;
4056 }
4057 /* From state DELETE to state MATCH */
4058 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
4059 if( temp > score ) {
4060 score = temp;
4061 }
4062 /* From state DELETE to state MATCH */
4063 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
4064 if( temp > score ) {
4065 score = temp;
4066 }
4067 /* From state DELETE to state MATCH */
4068 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
4069 if( temp > score ) {
4070 score = temp;
4071 }
4072
4073
4074 /* Ok - finished max calculation for MATCH */
4075 /* Add any movement independant score and put away */
4076 EstWise3_DC_SHADOW_MATRIX(mat,i,j,MATCH) = score;
4077 /* Finished calculating state MATCH */
4078
4079
4080 /* For state INSERT */
4081 /* setting first movement to score */
4082 score = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
4083 /* From state INSERT to state INSERT */
4084 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
4085 if( temp > score ) {
4086 score = temp;
4087 }
4088 /* From state DELETE to state INSERT */
4089 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
4090 if( temp > score ) {
4091 score = temp;
4092 }
4093 /* From state INSERT to state INSERT */
4094 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
4095 if( temp > score ) {
4096 score = temp;
4097 }
4098 /* From state INSERT to state INSERT */
4099 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
4100 if( temp > score ) {
4101 score = temp;
4102 }
4103 /* From state INSERT to state INSERT */
4104 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
4105 if( temp > score ) {
4106 score = temp;
4107 }
4108 /* From state INSERT to state INSERT */
4109 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
4110 if( temp > score ) {
4111 score = temp;
4112 }
4113 /* From state MATCH to state INSERT */
4114 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
4115 if( temp > score ) {
4116 score = temp;
4117 }
4118 /* From state MATCH to state INSERT */
4119 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
4120 if( temp > score ) {
4121 score = temp;
4122 }
4123 /* From state MATCH to state INSERT */
4124 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
4125 if( temp > score ) {
4126 score = temp;
4127 }
4128 /* From state MATCH to state INSERT */
4129 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
4130 if( temp > score ) {
4131 score = temp;
4132 }
4133 /* From state DELETE to state INSERT */
4134 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
4135 if( temp > score ) {
4136 score = temp;
4137 }
4138 /* From state DELETE to state INSERT */
4139 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
4140 if( temp > score ) {
4141 score = temp;
4142 }
4143 /* From state DELETE to state INSERT */
4144 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
4145 if( temp > score ) {
4146 score = temp;
4147 }
4148 /* From state DELETE to state INSERT */
4149 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-0,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
4150 if( temp > score ) {
4151 score = temp;
4152 }
4153
4154
4155 /* Ok - finished max calculation for INSERT */
4156 /* Add any movement independant score and put away */
4157 EstWise3_DC_SHADOW_MATRIX(mat,i,j,INSERT) = score;
4158 /* Finished calculating state INSERT */
4159
4160
4161 /* For state DELETE */
4162 /* setting first movement to score */
4163 score = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,MATCH) + mat->query->seg[i]->transition[GW_MATCH2DELETE];
4164 /* From state INSERT to state DELETE */
4165 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,INSERT) + mat->query->seg[i]->transition[GW_INSERT2DELETE];
4166 if( temp > score ) {
4167 score = temp;
4168 }
4169 /* From state DELETE to state DELETE */
4170 temp = EstWise3_DC_SHADOW_MATRIX(mat,i-1,j-0,DELETE) + mat->query->seg[i]->transition[GW_DELETE2DELETE];
4171 if( temp > score ) {
4172 score = temp;
4173 }
4174
4175
4176 /* Ok - finished max calculation for DELETE */
4177 /* Add any movement independant score and put away */
4178 EstWise3_DC_SHADOW_MATRIX(mat,i,j,DELETE) = score;
4179 /* Finished calculating state DELETE */
4180 } /* end of this is strip */
4181 } /* end of for each valid j column */
4182
4183
4184 /* Function: init_dc_EstWise3(mat)
4185 *
4186 * Descrip: No Description
4187 *
4188 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
4189 *
4190 */
4191 }
init_dc_EstWise3(EstWise3 * mat)4192 void init_dc_EstWise3(EstWise3 * mat)
4193 {
4194 register int i;
4195 register int j;
4196 register int k;
4197
4198
4199 for(j=0;j<7;j++) {
4200 for(i=(-1);i<mat->query->len;i++) {
4201 EstWise3_DC_SHADOW_MATRIX(mat,i,j,MATCH) = NEGI;
4202 EstWise3_DC_SHADOW_MATRIX(mat,i,j,INSERT) = NEGI;
4203 EstWise3_DC_SHADOW_MATRIX(mat,i,j,DELETE) = NEGI;
4204 for(k=0;k<7;k++) {
4205 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = (-1);
4206 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = (-1);
4207 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,k) = (-1);
4208 }
4209 }
4210 }
4211
4212
4213 return;
4214 }
4215
4216
4217 /* Function: start_end_find_end_EstWise3(mat,endj)
4218 *
4219 * Descrip: First function used to find end of the best path in the special state !end
4220 *
4221 *
4222 * Arg: mat [UNKN ] Matrix in small mode [EstWise3 *]
4223 * Arg: endj [WRITE] position of end in j (meaningless in i) [int *]
4224 *
4225 * Return [UNKN ] Undocumented return value [int]
4226 *
4227 */
start_end_find_end_EstWise3(EstWise3 * mat,int * endj)4228 int start_end_find_end_EstWise3(EstWise3 * mat,int * endj)
4229 {
4230 register int j;
4231 register int max;
4232 register int maxj;
4233
4234
4235 max = EstWise3_DC_SHADOW_SPECIAL(mat,0,mat->target->seq->len-1,END);
4236 maxj = mat->target->seq->len-1;
4237 for(j= mat->target->seq->len-2 ;j >= 0 ;j--) {
4238 if( EstWise3_DC_SHADOW_SPECIAL(mat,0,j,END) > max ) {
4239 max = EstWise3_DC_SHADOW_SPECIAL(mat,0,j,END);
4240 maxj = j;
4241 }
4242 }
4243
4244
4245 if( endj != NULL)
4246 *endj = maxj;
4247
4248
4249 return max;
4250 }
4251
4252
4253 /* Function: dc_optimised_start_end_calc_EstWise3(*mat,dpenv)
4254 *
4255 * Descrip: Calculates special strip, leaving start/end/score points in shadow matrix
4256 * Works off specially laid out memory from steve searle
4257 *
4258 *
4259 * Arg: *mat [UNKN ] Undocumented argument [EstWise3]
4260 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
4261 *
4262 * Return [UNKN ] Undocumented return value [boolean]
4263 *
4264 */
dc_optimised_start_end_calc_EstWise3(EstWise3 * mat,DPEnvelope * dpenv)4265 boolean dc_optimised_start_end_calc_EstWise3(EstWise3 *mat,DPEnvelope * dpenv)
4266 {
4267 int i;
4268 int j;
4269 int k;
4270 int score;
4271 int temp;
4272 int leni;
4273 int lenj;
4274 int localshadow[7];
4275 long int total;
4276 long int num=0;
4277 int * score_pointers;
4278 int * shadow_pointers;
4279 int * localsp;
4280 leni = mat->query->len;
4281 lenj = mat->target->seq->len;
4282 total = leni * lenj;
4283
4284
4285 score_pointers = (int *) calloc (5 * (leni + 1) * 3,sizeof(int));
4286 shadow_pointers = (int *) calloc (5 * (leni + 1) * 3 * 8,sizeof(int));
4287
4288
4289 for(j=0;j<lenj;j++) { /*for each j strip*/
4290 for(i=0;i<leni;i++) { /*for each i position in strip*/
4291 num++;
4292 if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE ) { /*Is not in envelope*/
4293 EstWise3_DC_OPT_SHADOW_MATRIX(mat,i,j,MATCH) = NEGI;
4294 EstWise3_DC_OPT_SHADOW_MATRIX(mat,i,j,INSERT) = NEGI;
4295 EstWise3_DC_OPT_SHADOW_MATRIX(mat,i,j,DELETE) = NEGI;
4296 continue;
4297 } /* end of Is not in envelope */
4298 if( num%1000 == 0)
4299 log_full_error(REPORT,0,"%6d Cells done [%2d%%%%]",num,num*100/total);
4300
4301
4302
4303
4304 /* For state MATCH */
4305 /* setting first movement to score */
4306 score = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
4307 /* assign local shadown pointer */
4308 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 3,MATCH,0));
4309 /* From state INSERT to state MATCH */
4310 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]) +(0);
4311 if( temp > score ) {
4312 score = temp;
4313 /* assign local shadown pointer */
4314 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 3,INSERT,0));
4315 }
4316 /* From state DELETE to state MATCH */
4317 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]) +(0);
4318 if( temp > score ) {
4319 score = temp;
4320 /* assign local shadown pointer */
4321 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 3,DELETE,0));
4322 }
4323 /* From state START to state MATCH */
4324 temp = EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i-1,j-3,START) + (mat->query->seg[i]->transition[GW_START2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
4325 if( temp > score ) {
4326 score = temp;
4327 /* This state [START] is a special for MATCH... push top shadow pointers here */
4328 localshadow[0]= i;
4329 localshadow[1]= j;
4330 localshadow[2]= MATCH;
4331 localshadow[3]= (-1);
4332 localshadow[4]= (-1);
4333 localshadow[5]= (-1);
4334 localshadow[6]= score;
4335 localsp = localshadow;
4336 }
4337 /* From state MATCH to state MATCH */
4338 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE] +(0);
4339 if( temp > score ) {
4340 score = temp;
4341 /* assign local shadown pointer */
4342 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 2,MATCH,0));
4343 }
4344 /* From state MATCH to state MATCH */
4345 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE] +(0);
4346 if( temp > score ) {
4347 score = temp;
4348 /* assign local shadown pointer */
4349 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 1,MATCH,0));
4350 }
4351 /* From state MATCH to state MATCH */
4352 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE] +(0);
4353 if( temp > score ) {
4354 score = temp;
4355 /* assign local shadown pointer */
4356 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 4,MATCH,0));
4357 }
4358 /* From state MATCH to state MATCH */
4359 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE] +(0);
4360 if( temp > score ) {
4361 score = temp;
4362 /* assign local shadown pointer */
4363 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 5,MATCH,0));
4364 }
4365 /* From state INSERT to state MATCH */
4366 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE] +(0);
4367 if( temp > score ) {
4368 score = temp;
4369 /* assign local shadown pointer */
4370 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 2,INSERT,0));
4371 }
4372 /* From state INSERT to state MATCH */
4373 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE] +(0);
4374 if( temp > score ) {
4375 score = temp;
4376 /* assign local shadown pointer */
4377 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 1,INSERT,0));
4378 }
4379 /* From state INSERT to state MATCH */
4380 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE] +(0);
4381 if( temp > score ) {
4382 score = temp;
4383 /* assign local shadown pointer */
4384 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 4,INSERT,0));
4385 }
4386 /* From state INSERT to state MATCH */
4387 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE] +(0);
4388 if( temp > score ) {
4389 score = temp;
4390 /* assign local shadown pointer */
4391 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 5,INSERT,0));
4392 }
4393 /* From state DELETE to state MATCH */
4394 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE] +(0);
4395 if( temp > score ) {
4396 score = temp;
4397 /* assign local shadown pointer */
4398 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 2,DELETE,0));
4399 }
4400 /* From state DELETE to state MATCH */
4401 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE] +(0);
4402 if( temp > score ) {
4403 score = temp;
4404 /* assign local shadown pointer */
4405 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 1,DELETE,0));
4406 }
4407 /* From state DELETE to state MATCH */
4408 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE] +(0);
4409 if( temp > score ) {
4410 score = temp;
4411 /* assign local shadown pointer */
4412 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 4,DELETE,0));
4413 }
4414 /* From state DELETE to state MATCH */
4415 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE] +(0);
4416 if( temp > score ) {
4417 score = temp;
4418 /* assign local shadown pointer */
4419 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 5,DELETE,0));
4420 }
4421
4422
4423 /* Ok - finished max calculation for MATCH */
4424 /* Add any movement independant score and put away */
4425 /* Actually, already done inside scores */
4426 EstWise3_DC_OPT_SHADOW_MATRIX(mat,i,j,MATCH) = score;
4427 for(k=0;k<7;k++)
4428 EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,MATCH,k) = localsp[k];
4429 /* Now figure out if any specials need this score */
4430
4431
4432 /* state MATCH is a source for special END */
4433 temp = score + (mat->query->seg[i]->transition[GW_MATCH2END]) + (0) ;
4434 if( temp > EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i,j,END) ) {
4435 EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i,j,END) = temp;
4436 /* Have to push only bottem half of system here */
4437 for(k=0;k<3;k++)
4438 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,k) = EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,MATCH,k);
4439 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,6) = EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,MATCH,6);
4440 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,3) = i;
4441 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,4) = j;
4442 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,5) = MATCH;
4443 }
4444
4445
4446
4447
4448 /* Finished calculating state MATCH */
4449
4450
4451 /* For state INSERT */
4452 /* setting first movement to score */
4453 score = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
4454 /* assign local shadown pointer */
4455 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 3,MATCH,0));
4456 /* From state INSERT to state INSERT */
4457 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]) +(0);
4458 if( temp > score ) {
4459 score = temp;
4460 /* assign local shadown pointer */
4461 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 3,INSERT,0));
4462 }
4463 /* From state DELETE to state INSERT */
4464 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]) +(0);
4465 if( temp > score ) {
4466 score = temp;
4467 /* assign local shadown pointer */
4468 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 3,DELETE,0));
4469 }
4470 /* From state START to state INSERT */
4471 temp = EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i-0,j-3,START) + (mat->query->seg[i]->transition[GW_START2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]) + (0);
4472 if( temp > score ) {
4473 score = temp;
4474 /* This state [START] is a special for INSERT... push top shadow pointers here */
4475 localshadow[0]= i;
4476 localshadow[1]= j;
4477 localshadow[2]= INSERT;
4478 localshadow[3]= (-1);
4479 localshadow[4]= (-1);
4480 localshadow[5]= (-1);
4481 localshadow[6]= score;
4482 localsp = localshadow;
4483 }
4484 /* From state INSERT to state INSERT */
4485 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE] +(0);
4486 if( temp > score ) {
4487 score = temp;
4488 /* assign local shadown pointer */
4489 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 2,INSERT,0));
4490 }
4491 /* From state INSERT to state INSERT */
4492 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE] +(0);
4493 if( temp > score ) {
4494 score = temp;
4495 /* assign local shadown pointer */
4496 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 1,INSERT,0));
4497 }
4498 /* From state INSERT to state INSERT */
4499 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE] +(0);
4500 if( temp > score ) {
4501 score = temp;
4502 /* assign local shadown pointer */
4503 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 4,INSERT,0));
4504 }
4505 /* From state INSERT to state INSERT */
4506 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE] +(0);
4507 if( temp > score ) {
4508 score = temp;
4509 /* assign local shadown pointer */
4510 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 5,INSERT,0));
4511 }
4512 /* From state MATCH to state INSERT */
4513 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE] +(0);
4514 if( temp > score ) {
4515 score = temp;
4516 /* assign local shadown pointer */
4517 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 2,MATCH,0));
4518 }
4519 /* From state MATCH to state INSERT */
4520 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE] +(0);
4521 if( temp > score ) {
4522 score = temp;
4523 /* assign local shadown pointer */
4524 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 1,MATCH,0));
4525 }
4526 /* From state MATCH to state INSERT */
4527 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE] +(0);
4528 if( temp > score ) {
4529 score = temp;
4530 /* assign local shadown pointer */
4531 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 4,MATCH,0));
4532 }
4533 /* From state MATCH to state INSERT */
4534 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE] +(0);
4535 if( temp > score ) {
4536 score = temp;
4537 /* assign local shadown pointer */
4538 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 5,MATCH,0));
4539 }
4540 /* From state DELETE to state INSERT */
4541 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE] +(0);
4542 if( temp > score ) {
4543 score = temp;
4544 /* assign local shadown pointer */
4545 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 2,DELETE,0));
4546 }
4547 /* From state DELETE to state INSERT */
4548 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE] +(0);
4549 if( temp > score ) {
4550 score = temp;
4551 /* assign local shadown pointer */
4552 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 1,DELETE,0));
4553 }
4554 /* From state DELETE to state INSERT */
4555 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE] +(0);
4556 if( temp > score ) {
4557 score = temp;
4558 /* assign local shadown pointer */
4559 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 4,DELETE,0));
4560 }
4561 /* From state DELETE to state INSERT */
4562 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-0,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE] +(0);
4563 if( temp > score ) {
4564 score = temp;
4565 /* assign local shadown pointer */
4566 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 0,j - 5,DELETE,0));
4567 }
4568
4569
4570 /* Ok - finished max calculation for INSERT */
4571 /* Add any movement independant score and put away */
4572 /* Actually, already done inside scores */
4573 EstWise3_DC_OPT_SHADOW_MATRIX(mat,i,j,INSERT) = score;
4574 for(k=0;k<7;k++)
4575 EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,INSERT,k) = localsp[k];
4576 /* Now figure out if any specials need this score */
4577
4578
4579 /* state INSERT is a source for special END */
4580 temp = score + (mat->query->seg[i]->transition[GW_INSERT2END]) + (0) ;
4581 if( temp > EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i,j,END) ) {
4582 EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i,j,END) = temp;
4583 /* Have to push only bottem half of system here */
4584 for(k=0;k<3;k++)
4585 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,k) = EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,INSERT,k);
4586 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,6) = EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,INSERT,6);
4587 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,3) = i;
4588 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,4) = j;
4589 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,5) = INSERT;
4590 }
4591
4592
4593
4594
4595 /* Finished calculating state INSERT */
4596
4597
4598 /* For state DELETE */
4599 /* setting first movement to score */
4600 score = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-0,MATCH) + mat->query->seg[i]->transition[GW_MATCH2DELETE] + (0);
4601 /* assign local shadown pointer */
4602 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 0,MATCH,0));
4603 /* From state INSERT to state DELETE */
4604 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-0,INSERT) + mat->query->seg[i]->transition[GW_INSERT2DELETE] +(0);
4605 if( temp > score ) {
4606 score = temp;
4607 /* assign local shadown pointer */
4608 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 0,INSERT,0));
4609 }
4610 /* From state DELETE to state DELETE */
4611 temp = EstWise3_DC_OPT_SHADOW_MATRIX(mat,i-1,j-0,DELETE) + mat->query->seg[i]->transition[GW_DELETE2DELETE] +(0);
4612 if( temp > score ) {
4613 score = temp;
4614 /* assign local shadown pointer */
4615 localsp = &(EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i - 1,j - 0,DELETE,0));
4616 }
4617 /* From state START to state DELETE */
4618 temp = EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i-1,j-0,START) + mat->query->seg[i]->transition[GW_START2DELETE] + (0);
4619 if( temp > score ) {
4620 score = temp;
4621 /* This state [START] is a special for DELETE... push top shadow pointers here */
4622 localshadow[0]= i;
4623 localshadow[1]= j;
4624 localshadow[2]= DELETE;
4625 localshadow[3]= (-1);
4626 localshadow[4]= (-1);
4627 localshadow[5]= (-1);
4628 localshadow[6]= score;
4629 localsp = localshadow;
4630 }
4631
4632
4633 /* Ok - finished max calculation for DELETE */
4634 /* Add any movement independant score and put away */
4635 /* Actually, already done inside scores */
4636 EstWise3_DC_OPT_SHADOW_MATRIX(mat,i,j,DELETE) = score;
4637 for(k=0;k<7;k++)
4638 EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,DELETE,k) = localsp[k];
4639 /* Now figure out if any specials need this score */
4640
4641
4642 /* state DELETE is a source for special END */
4643 temp = score + (mat->query->seg[i]->transition[GW_DELETE2END]) + (0) ;
4644 if( temp > EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i,j,END) ) {
4645 EstWise3_DC_OPT_SHADOW_SPECIAL(mat,i,j,END) = temp;
4646 /* Have to push only bottem half of system here */
4647 for(k=0;k<3;k++)
4648 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,k) = EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,DELETE,k);
4649 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,6) = EstWise3_DC_OPT_SHADOW_MATRIX_SP(mat,i,j,DELETE,6);
4650 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,3) = i;
4651 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,4) = j;
4652 EstWise3_DC_OPT_SHADOW_SPECIAL_SP(mat,i,j,END,5) = DELETE;
4653 }
4654
4655
4656
4657
4658 /* Finished calculating state DELETE */
4659
4660
4661 } /* end of for each i position in strip */
4662 } /* end of for each j strip */
4663 free(score_pointers);
4664 free(shadow_pointers);
4665 return TRUE;
4666 }
4667
4668
4669 /* Function: init_start_end_linear_EstWise3(mat)
4670 *
4671 * Descrip: No Description
4672 *
4673 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
4674 *
4675 */
init_start_end_linear_EstWise3(EstWise3 * mat)4676 void init_start_end_linear_EstWise3(EstWise3 * mat)
4677 {
4678 register int i;
4679 register int j;
4680 for(j=0;j<7;j++) {
4681 for(i=(-1);i<mat->query->len;i++) {
4682 EstWise3_DC_SHADOW_MATRIX(mat,i,j,MATCH) = NEGI;
4683 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,MATCH,0) = (-1);
4684 EstWise3_DC_SHADOW_MATRIX(mat,i,j,INSERT) = NEGI;
4685 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,INSERT,0) = (-1);
4686 EstWise3_DC_SHADOW_MATRIX(mat,i,j,DELETE) = NEGI;
4687 EstWise3_DC_SHADOW_MATRIX_SP(mat,i,j,DELETE,0) = (-1);
4688 }
4689 }
4690
4691
4692 for(j=(-5);j<mat->target->seq->len;j++) {
4693 EstWise3_DC_SHADOW_SPECIAL(mat,0,j,START) = 0;
4694 EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,j,START,0) = j;
4695 EstWise3_DC_SHADOW_SPECIAL(mat,0,j,END) = NEGI;
4696 EstWise3_DC_SHADOW_SPECIAL_SP(mat,0,j,END,0) = (-1);
4697 }
4698
4699
4700 return;
4701 }
4702
4703
4704 /* Function: convert_PackAln_to_AlnBlock_EstWise3(pal)
4705 *
4706 * Descrip: Converts a path alignment to a label alignment
4707 * The label alignment is probably much more useful than the path
4708 *
4709 *
4710 * Arg: pal [UNKN ] Undocumented argument [PackAln *]
4711 *
4712 * Return [UNKN ] Undocumented return value [AlnBlock *]
4713 *
4714 */
convert_PackAln_to_AlnBlock_EstWise3(PackAln * pal)4715 AlnBlock * convert_PackAln_to_AlnBlock_EstWise3(PackAln * pal)
4716 {
4717 AlnConvertSet * acs;
4718 AlnBlock * alb;
4719
4720
4721 acs = AlnConvertSet_EstWise3();
4722 alb = AlnBlock_from_PackAln(acs,pal);
4723 free_AlnConvertSet(acs);
4724 return alb;
4725 }
4726
4727
4728 static char * query_label[] = { "MATCH_STATE","INSERT_STATE","DELETE_STATE","END" };
4729 /* Function: AlnConvertSet_EstWise3(void)
4730 *
4731 * Descrip: No Description
4732 *
4733 *
4734 * Return [UNKN ] Undocumented return value [AlnConvertSet *]
4735 *
4736 */
4737 static char * target_label[] = { "CODON","SEQUENCE_DELETION","SEQUENCE_INSERTION","INSERT","END" };
AlnConvertSet_EstWise3(void)4738 AlnConvertSet * AlnConvertSet_EstWise3(void)
4739 {
4740 AlnConvertUnit * acu;
4741 AlnConvertSet * out;
4742
4743
4744 out = AlnConvertSet_alloc_std();
4745
4746
4747 acu = AlnConvertUnit_alloc();
4748 add_AlnConvertSet(out,acu);
4749 acu->state1 = MATCH;
4750 acu->state2 = MATCH;
4751 acu->offi = 1;
4752 acu->offj = 3;
4753 acu->label1 = query_label[0];
4754 acu->label2 = target_label[0];
4755 acu = AlnConvertUnit_alloc();
4756 add_AlnConvertSet(out,acu);
4757 acu->state1 = INSERT;
4758 acu->state2 = MATCH;
4759 acu->offi = 1;
4760 acu->offj = 3;
4761 acu->label1 = query_label[0];
4762 acu->label2 = target_label[0];
4763 acu = AlnConvertUnit_alloc();
4764 add_AlnConvertSet(out,acu);
4765 acu->state1 = DELETE;
4766 acu->state2 = MATCH;
4767 acu->offi = 1;
4768 acu->offj = 3;
4769 acu->label1 = query_label[0];
4770 acu->label2 = target_label[0];
4771 acu = AlnConvertUnit_alloc();
4772 add_AlnConvertSet(out,acu);
4773 acu->state1 = START + 3;
4774 acu->is_from_special = TRUE;
4775 acu->state2 = MATCH;
4776 acu->offi = (-1);
4777 acu->offj = 3;
4778 acu->label1 = query_label[0];
4779 acu->label2 = target_label[0];
4780 acu = AlnConvertUnit_alloc();
4781 add_AlnConvertSet(out,acu);
4782 acu->state1 = MATCH;
4783 acu->state2 = MATCH;
4784 acu->offi = 1;
4785 acu->offj = 2;
4786 acu->label1 = query_label[0];
4787 acu->label2 = target_label[1];
4788 acu = AlnConvertUnit_alloc();
4789 add_AlnConvertSet(out,acu);
4790 acu->state1 = MATCH;
4791 acu->state2 = MATCH;
4792 acu->offi = 1;
4793 acu->offj = 1;
4794 acu->label1 = query_label[0];
4795 acu->label2 = target_label[1];
4796 acu = AlnConvertUnit_alloc();
4797 add_AlnConvertSet(out,acu);
4798 acu->state1 = MATCH;
4799 acu->state2 = MATCH;
4800 acu->offi = 1;
4801 acu->offj = 4;
4802 acu->label1 = query_label[0];
4803 acu->label2 = target_label[2];
4804 acu = AlnConvertUnit_alloc();
4805 add_AlnConvertSet(out,acu);
4806 acu->state1 = MATCH;
4807 acu->state2 = MATCH;
4808 acu->offi = 1;
4809 acu->offj = 5;
4810 acu->label1 = query_label[0];
4811 acu->label2 = target_label[2];
4812 acu = AlnConvertUnit_alloc();
4813 add_AlnConvertSet(out,acu);
4814 acu->state1 = INSERT;
4815 acu->state2 = MATCH;
4816 acu->offi = 1;
4817 acu->offj = 2;
4818 acu->label1 = query_label[0];
4819 acu->label2 = target_label[1];
4820 acu = AlnConvertUnit_alloc();
4821 add_AlnConvertSet(out,acu);
4822 acu->state1 = INSERT;
4823 acu->state2 = MATCH;
4824 acu->offi = 1;
4825 acu->offj = 1;
4826 acu->label1 = query_label[0];
4827 acu->label2 = target_label[1];
4828 acu = AlnConvertUnit_alloc();
4829 add_AlnConvertSet(out,acu);
4830 acu->state1 = INSERT;
4831 acu->state2 = MATCH;
4832 acu->offi = 1;
4833 acu->offj = 4;
4834 acu->label1 = query_label[0];
4835 acu->label2 = target_label[2];
4836 acu = AlnConvertUnit_alloc();
4837 add_AlnConvertSet(out,acu);
4838 acu->state1 = INSERT;
4839 acu->state2 = MATCH;
4840 acu->offi = 1;
4841 acu->offj = 5;
4842 acu->label1 = query_label[0];
4843 acu->label2 = target_label[2];
4844 acu = AlnConvertUnit_alloc();
4845 add_AlnConvertSet(out,acu);
4846 acu->state1 = DELETE;
4847 acu->state2 = MATCH;
4848 acu->offi = 1;
4849 acu->offj = 2;
4850 acu->label1 = query_label[0];
4851 acu->label2 = target_label[1];
4852 acu = AlnConvertUnit_alloc();
4853 add_AlnConvertSet(out,acu);
4854 acu->state1 = DELETE;
4855 acu->state2 = MATCH;
4856 acu->offi = 1;
4857 acu->offj = 1;
4858 acu->label1 = query_label[0];
4859 acu->label2 = target_label[1];
4860 acu = AlnConvertUnit_alloc();
4861 add_AlnConvertSet(out,acu);
4862 acu->state1 = DELETE;
4863 acu->state2 = MATCH;
4864 acu->offi = 1;
4865 acu->offj = 4;
4866 acu->label1 = query_label[0];
4867 acu->label2 = target_label[2];
4868 acu = AlnConvertUnit_alloc();
4869 add_AlnConvertSet(out,acu);
4870 acu->state1 = DELETE;
4871 acu->state2 = MATCH;
4872 acu->offi = 1;
4873 acu->offj = 5;
4874 acu->label1 = query_label[0];
4875 acu->label2 = target_label[2];
4876 acu = AlnConvertUnit_alloc();
4877 add_AlnConvertSet(out,acu);
4878 acu->state1 = MATCH;
4879 acu->state2 = INSERT;
4880 acu->offi = 0;
4881 acu->offj = 3;
4882 acu->label1 = query_label[1];
4883 acu->label2 = target_label[0];
4884 acu = AlnConvertUnit_alloc();
4885 add_AlnConvertSet(out,acu);
4886 acu->state1 = INSERT;
4887 acu->state2 = INSERT;
4888 acu->offi = 0;
4889 acu->offj = 3;
4890 acu->label1 = query_label[1];
4891 acu->label2 = target_label[0];
4892 acu = AlnConvertUnit_alloc();
4893 add_AlnConvertSet(out,acu);
4894 acu->state1 = DELETE;
4895 acu->state2 = INSERT;
4896 acu->offi = 0;
4897 acu->offj = 3;
4898 acu->label1 = query_label[1];
4899 acu->label2 = target_label[0];
4900 acu = AlnConvertUnit_alloc();
4901 add_AlnConvertSet(out,acu);
4902 acu->state1 = START + 3;
4903 acu->is_from_special = TRUE;
4904 acu->state2 = INSERT;
4905 acu->offi = (-1);
4906 acu->offj = 3;
4907 acu->label1 = query_label[1];
4908 acu->label2 = target_label[0];
4909 acu = AlnConvertUnit_alloc();
4910 add_AlnConvertSet(out,acu);
4911 acu->state1 = INSERT;
4912 acu->state2 = INSERT;
4913 acu->offi = 0;
4914 acu->offj = 2;
4915 acu->label1 = query_label[1];
4916 acu->label2 = target_label[1];
4917 acu = AlnConvertUnit_alloc();
4918 add_AlnConvertSet(out,acu);
4919 acu->state1 = INSERT;
4920 acu->state2 = INSERT;
4921 acu->offi = 0;
4922 acu->offj = 1;
4923 acu->label1 = query_label[1];
4924 acu->label2 = target_label[1];
4925 acu = AlnConvertUnit_alloc();
4926 add_AlnConvertSet(out,acu);
4927 acu->state1 = INSERT;
4928 acu->state2 = INSERT;
4929 acu->offi = 0;
4930 acu->offj = 4;
4931 acu->label1 = query_label[1];
4932 acu->label2 = target_label[2];
4933 acu = AlnConvertUnit_alloc();
4934 add_AlnConvertSet(out,acu);
4935 acu->state1 = INSERT;
4936 acu->state2 = INSERT;
4937 acu->offi = 0;
4938 acu->offj = 5;
4939 acu->label1 = query_label[1];
4940 acu->label2 = target_label[2];
4941 acu = AlnConvertUnit_alloc();
4942 add_AlnConvertSet(out,acu);
4943 acu->state1 = MATCH;
4944 acu->state2 = INSERT;
4945 acu->offi = 0;
4946 acu->offj = 2;
4947 acu->label1 = query_label[1];
4948 acu->label2 = target_label[1];
4949 acu = AlnConvertUnit_alloc();
4950 add_AlnConvertSet(out,acu);
4951 acu->state1 = MATCH;
4952 acu->state2 = INSERT;
4953 acu->offi = 0;
4954 acu->offj = 1;
4955 acu->label1 = query_label[1];
4956 acu->label2 = target_label[1];
4957 acu = AlnConvertUnit_alloc();
4958 add_AlnConvertSet(out,acu);
4959 acu->state1 = MATCH;
4960 acu->state2 = INSERT;
4961 acu->offi = 0;
4962 acu->offj = 4;
4963 acu->label1 = query_label[1];
4964 acu->label2 = target_label[2];
4965 acu = AlnConvertUnit_alloc();
4966 add_AlnConvertSet(out,acu);
4967 acu->state1 = MATCH;
4968 acu->state2 = INSERT;
4969 acu->offi = 0;
4970 acu->offj = 5;
4971 acu->label1 = query_label[1];
4972 acu->label2 = target_label[2];
4973 acu = AlnConvertUnit_alloc();
4974 add_AlnConvertSet(out,acu);
4975 acu->state1 = DELETE;
4976 acu->state2 = INSERT;
4977 acu->offi = 0;
4978 acu->offj = 2;
4979 acu->label1 = query_label[1];
4980 acu->label2 = target_label[1];
4981 acu = AlnConvertUnit_alloc();
4982 add_AlnConvertSet(out,acu);
4983 acu->state1 = DELETE;
4984 acu->state2 = INSERT;
4985 acu->offi = 0;
4986 acu->offj = 1;
4987 acu->label1 = query_label[1];
4988 acu->label2 = target_label[1];
4989 acu = AlnConvertUnit_alloc();
4990 add_AlnConvertSet(out,acu);
4991 acu->state1 = DELETE;
4992 acu->state2 = INSERT;
4993 acu->offi = 0;
4994 acu->offj = 4;
4995 acu->label1 = query_label[1];
4996 acu->label2 = target_label[2];
4997 acu = AlnConvertUnit_alloc();
4998 add_AlnConvertSet(out,acu);
4999 acu->state1 = DELETE;
5000 acu->state2 = INSERT;
5001 acu->offi = 0;
5002 acu->offj = 5;
5003 acu->label1 = query_label[1];
5004 acu->label2 = target_label[2];
5005 acu = AlnConvertUnit_alloc();
5006 add_AlnConvertSet(out,acu);
5007 acu->state1 = MATCH;
5008 acu->state2 = DELETE;
5009 acu->offi = 1;
5010 acu->offj = 0;
5011 acu->label1 = query_label[2];
5012 acu->label2 = target_label[3];
5013 acu = AlnConvertUnit_alloc();
5014 add_AlnConvertSet(out,acu);
5015 acu->state1 = INSERT;
5016 acu->state2 = DELETE;
5017 acu->offi = 1;
5018 acu->offj = 0;
5019 acu->label1 = query_label[2];
5020 acu->label2 = target_label[3];
5021 acu = AlnConvertUnit_alloc();
5022 add_AlnConvertSet(out,acu);
5023 acu->state1 = DELETE;
5024 acu->state2 = DELETE;
5025 acu->offi = 1;
5026 acu->offj = 0;
5027 acu->label1 = query_label[2];
5028 acu->label2 = target_label[3];
5029 acu = AlnConvertUnit_alloc();
5030 add_AlnConvertSet(out,acu);
5031 acu->state1 = START + 3;
5032 acu->is_from_special = TRUE;
5033 acu->state2 = DELETE;
5034 acu->offi = (-1);
5035 acu->offj = 0;
5036 acu->label1 = query_label[2];
5037 acu->label2 = target_label[3];
5038 acu = AlnConvertUnit_alloc();
5039 add_AlnConvertSet(out,acu);
5040 acu->state1 = MATCH;
5041 acu->state2 = END + 3;
5042 acu->offi = (-1);
5043 acu->offj = 0;
5044 acu->label1 = query_label[3];
5045 acu->label2 = target_label[4];
5046 acu = AlnConvertUnit_alloc();
5047 add_AlnConvertSet(out,acu);
5048 acu->state1 = INSERT;
5049 acu->state2 = END + 3;
5050 acu->offi = (-1);
5051 acu->offj = 0;
5052 acu->label1 = query_label[3];
5053 acu->label2 = target_label[4];
5054 acu = AlnConvertUnit_alloc();
5055 add_AlnConvertSet(out,acu);
5056 acu->state1 = DELETE;
5057 acu->state2 = END + 3;
5058 acu->offi = (-1);
5059 acu->offj = 0;
5060 acu->label1 = query_label[3];
5061 acu->label2 = target_label[4];
5062 return out;
5063 }
5064
5065
5066 /* Function: PackAln_read_Expl_EstWise3(mat)
5067 *
5068 * Descrip: Reads off PackAln from explicit matrix structure
5069 *
5070 *
5071 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
5072 *
5073 * Return [UNKN ] Undocumented return value [PackAln *]
5074 *
5075 */
PackAln_read_Expl_EstWise3(EstWise3 * mat)5076 PackAln * PackAln_read_Expl_EstWise3(EstWise3 * mat)
5077 {
5078 EstWise3_access_func_holder holder;
5079
5080
5081 holder.access_main = EstWise3_explicit_access_main;
5082 holder.access_special = EstWise3_explicit_access_special;
5083 return PackAln_read_generic_EstWise3(mat,holder);
5084 }
5085
5086
5087 /* Function: EstWise3_explicit_access_main(mat,i,j,state)
5088 *
5089 * Descrip: No Description
5090 *
5091 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
5092 * Arg: i [UNKN ] Undocumented argument [int]
5093 * Arg: j [UNKN ] Undocumented argument [int]
5094 * Arg: state [UNKN ] Undocumented argument [int]
5095 *
5096 * Return [UNKN ] Undocumented return value [int]
5097 *
5098 */
EstWise3_explicit_access_main(EstWise3 * mat,int i,int j,int state)5099 int EstWise3_explicit_access_main(EstWise3 * mat,int i,int j,int state)
5100 {
5101 return EstWise3_EXPL_MATRIX(mat,i,j,state);
5102 }
5103
5104
5105 /* Function: EstWise3_explicit_access_special(mat,i,j,state)
5106 *
5107 * Descrip: No Description
5108 *
5109 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
5110 * Arg: i [UNKN ] Undocumented argument [int]
5111 * Arg: j [UNKN ] Undocumented argument [int]
5112 * Arg: state [UNKN ] Undocumented argument [int]
5113 *
5114 * Return [UNKN ] Undocumented return value [int]
5115 *
5116 */
EstWise3_explicit_access_special(EstWise3 * mat,int i,int j,int state)5117 int EstWise3_explicit_access_special(EstWise3 * mat,int i,int j,int state)
5118 {
5119 return EstWise3_EXPL_SPECIAL(mat,i,j,state);
5120 }
5121
5122
5123 /* Function: PackAln_read_generic_EstWise3(mat,h)
5124 *
5125 * Descrip: Reads off PackAln from explicit matrix structure
5126 *
5127 *
5128 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
5129 * Arg: h [UNKN ] Undocumented argument [EstWise3_access_func_holder]
5130 *
5131 * Return [UNKN ] Undocumented return value [PackAln *]
5132 *
5133 */
PackAln_read_generic_EstWise3(EstWise3 * mat,EstWise3_access_func_holder h)5134 PackAln * PackAln_read_generic_EstWise3(EstWise3 * mat,EstWise3_access_func_holder h)
5135 {
5136 register PackAln * out;
5137 int i;
5138 int j;
5139 int state;
5140 int cellscore = (-1);
5141 boolean isspecial;
5142 PackAlnUnit * pau = NULL;
5143 PackAlnUnit * prev = NULL;
5144
5145
5146 assert(mat);
5147 assert(h.access_main);
5148 assert(h.access_special);
5149
5150
5151 out = PackAln_alloc_std();
5152 if( out == NULL )
5153 return NULL;
5154
5155
5156 out->score = find_end_EstWise3(mat,&i,&j,&state,&isspecial,h);
5157
5158
5159 /* Add final end transition (at the moment we have not got the score! */
5160 if( (pau= PackAlnUnit_alloc()) == NULL || add_PackAln(out,pau) == FALSE ) {
5161 warn("Failed the first PackAlnUnit alloc, %d length of Alignment in EstWise3_basic_read, returning a mess.(Sorry!)",out->len);
5162 return out;
5163 }
5164
5165
5166 /* Put in positions for end trans. Remember that coordinates in C style */
5167 pau->i = i;
5168 pau->j = j;
5169 if( isspecial != TRUE)
5170 pau->state = state;
5171 else pau->state = state + 3;
5172 prev=pau;
5173 while( state != START || isspecial != TRUE) { /*while state != START*/
5174
5175
5176 if( isspecial == TRUE )
5177 max_calc_special_EstWise3(mat,i,j,state,isspecial,&i,&j,&state,&isspecial,&cellscore,h);
5178 else
5179 max_calc_EstWise3(mat,i,j,state,isspecial,&i,&j,&state,&isspecial,&cellscore,h);
5180 if(i == EstWise3_READ_OFF_ERROR || j == EstWise3_READ_OFF_ERROR || state == EstWise3_READ_OFF_ERROR ) {
5181 warn("Problem - hit bad read off system, exiting now");
5182 break;
5183 }
5184 if( (pau= PackAlnUnit_alloc()) == NULL || add_PackAln(out,pau) == FALSE ) {
5185 warn("Failed a PackAlnUnit alloc, %d length of Alignment in EstWise3_basic_read, returning partial alignment",out->len);
5186 break;
5187 }
5188
5189
5190 /* Put in positions for block. Remember that coordinates in C style */
5191 pau->i = i;
5192 pau->j = j;
5193 if( isspecial != TRUE)
5194 pau->state = state;
5195 else pau->state = state + 3;
5196 prev->score = cellscore;
5197 prev = pau;
5198 } /* end of while state != START */
5199
5200
5201 invert_PackAln(out);
5202 return out;
5203 }
5204
5205
5206 /* Function: find_end_EstWise3(mat,ri,rj,state,isspecial,h)
5207 *
5208 * Descrip: No Description
5209 *
5210 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
5211 * Arg: ri [UNKN ] Undocumented argument [int *]
5212 * Arg: rj [UNKN ] Undocumented argument [int *]
5213 * Arg: state [UNKN ] Undocumented argument [int *]
5214 * Arg: isspecial [UNKN ] Undocumented argument [boolean *]
5215 * Arg: h [UNKN ] Undocumented argument [EstWise3_access_func_holder]
5216 *
5217 * Return [UNKN ] Undocumented return value [int]
5218 *
5219 */
find_end_EstWise3(EstWise3 * mat,int * ri,int * rj,int * state,boolean * isspecial,EstWise3_access_func_holder h)5220 int find_end_EstWise3(EstWise3 * mat,int * ri,int * rj,int * state,boolean * isspecial,EstWise3_access_func_holder h)
5221 {
5222 int j;
5223 int max;
5224 int maxj;
5225 int temp;
5226
5227
5228 max = (*h.access_special)(mat,0,mat->target->seq->len-1,END);
5229 maxj = mat->target->seq->len-1;
5230 for(j= mat->target->seq->len-2 ;j >= 0 ;j--) {
5231 if( (temp =(*h.access_special)(mat,0,j,END)) > max ) {
5232 max = temp;
5233 maxj = j;
5234 }
5235 }
5236
5237
5238 if( ri != NULL)
5239 *ri = 0;
5240 if( rj != NULL)
5241 *rj = maxj;
5242 if( state != NULL)
5243 *state = END;
5244 if( isspecial != NULL)
5245 *isspecial = TRUE;
5246
5247
5248 return max;
5249 }
5250
5251
5252 /* Function: EstWise3_debug_show_matrix(mat,starti,stopi,startj,stopj,ofp)
5253 *
5254 * Descrip: No Description
5255 *
5256 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
5257 * Arg: starti [UNKN ] Undocumented argument [int]
5258 * Arg: stopi [UNKN ] Undocumented argument [int]
5259 * Arg: startj [UNKN ] Undocumented argument [int]
5260 * Arg: stopj [UNKN ] Undocumented argument [int]
5261 * Arg: ofp [UNKN ] Undocumented argument [FILE *]
5262 *
5263 */
EstWise3_debug_show_matrix(EstWise3 * mat,int starti,int stopi,int startj,int stopj,FILE * ofp)5264 void EstWise3_debug_show_matrix(EstWise3 * mat,int starti,int stopi,int startj,int stopj,FILE * ofp)
5265 {
5266 register int i;
5267 register int j;
5268
5269
5270 for(i=starti;i<stopi && i < mat->query->len;i++) {
5271 for(j=startj;j<stopj && j < mat->target->seq->len;j++) {
5272 fprintf(ofp,"Cell [%d - %d]\n",i,j);
5273 fprintf(ofp,"State MATCH %d\n",EstWise3_EXPL_MATRIX(mat,i,j,MATCH));
5274 fprintf(ofp,"State INSERT %d\n",EstWise3_EXPL_MATRIX(mat,i,j,INSERT));
5275 fprintf(ofp,"State DELETE %d\n",EstWise3_EXPL_MATRIX(mat,i,j,DELETE));
5276 fprintf(ofp,"\n\n");
5277 }
5278 }
5279
5280
5281 }
5282
5283
5284 /* Function: max_calc_EstWise3(mat,i,j,state,isspecial,reti,retj,retstate,retspecial,cellscore,h)
5285 *
5286 * Descrip: No Description
5287 *
5288 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
5289 * Arg: i [UNKN ] Undocumented argument [int]
5290 * Arg: j [UNKN ] Undocumented argument [int]
5291 * Arg: state [UNKN ] Undocumented argument [int]
5292 * Arg: isspecial [UNKN ] Undocumented argument [boolean]
5293 * Arg: reti [UNKN ] Undocumented argument [int *]
5294 * Arg: retj [UNKN ] Undocumented argument [int *]
5295 * Arg: retstate [UNKN ] Undocumented argument [int *]
5296 * Arg: retspecial [UNKN ] Undocumented argument [boolean *]
5297 * Arg: cellscore [UNKN ] Undocumented argument [int *]
5298 * Arg: h [UNKN ] Undocumented argument [EstWise3_access_func_holder]
5299 *
5300 * Return [UNKN ] Undocumented return value [int]
5301 *
5302 */
max_calc_EstWise3(EstWise3 * mat,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore,EstWise3_access_func_holder h)5303 int max_calc_EstWise3(EstWise3 * mat,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore,EstWise3_access_func_holder h)
5304 {
5305 register int temp;
5306 register int cscore;
5307
5308
5309 *reti = (*retj) = (*retstate) = EstWise3_READ_OFF_ERROR;
5310
5311
5312 if( i < 0 || j < 0 || i > mat->query->len || j > mat->target->seq->len) {
5313 warn("In EstWise3 matrix special read off - out of bounds on matrix [i,j is %d,%d state %d in standard matrix]",i,j,state);
5314 return -1;
5315 }
5316
5317
5318 /* Then you have to select the correct switch statement to figure out the readoff */
5319 /* Somewhat odd - reverse the order of calculation and return as soon as it is correct */
5320 cscore = (*h.access_main)(mat,i,j,state);
5321 switch(state) { /*Switch state */
5322 case MATCH :
5323 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
5324 if( temp == (*h.access_main)(mat,i - 1,j - 5,DELETE) ) {
5325 *reti = i - 1;
5326 *retj = j - 5;
5327 *retstate = DELETE;
5328 *retspecial = FALSE;
5329 if( cellscore != NULL) {
5330 *cellscore = cscore - (*h.access_main)(mat,i-1,j-5,DELETE);
5331 }
5332 return (*h.access_main)(mat,i - 1,j - 5,DELETE);
5333 }
5334 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
5335 if( temp == (*h.access_main)(mat,i - 1,j - 4,DELETE) ) {
5336 *reti = i - 1;
5337 *retj = j - 4;
5338 *retstate = DELETE;
5339 *retspecial = FALSE;
5340 if( cellscore != NULL) {
5341 *cellscore = cscore - (*h.access_main)(mat,i-1,j-4,DELETE);
5342 }
5343 return (*h.access_main)(mat,i - 1,j - 4,DELETE);
5344 }
5345 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
5346 if( temp == (*h.access_main)(mat,i - 1,j - 1,DELETE) ) {
5347 *reti = i - 1;
5348 *retj = j - 1;
5349 *retstate = DELETE;
5350 *retspecial = FALSE;
5351 if( cellscore != NULL) {
5352 *cellscore = cscore - (*h.access_main)(mat,i-1,j-1,DELETE);
5353 }
5354 return (*h.access_main)(mat,i - 1,j - 1,DELETE);
5355 }
5356 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
5357 if( temp == (*h.access_main)(mat,i - 1,j - 2,DELETE) ) {
5358 *reti = i - 1;
5359 *retj = j - 2;
5360 *retstate = DELETE;
5361 *retspecial = FALSE;
5362 if( cellscore != NULL) {
5363 *cellscore = cscore - (*h.access_main)(mat,i-1,j-2,DELETE);
5364 }
5365 return (*h.access_main)(mat,i - 1,j - 2,DELETE);
5366 }
5367 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
5368 if( temp == (*h.access_main)(mat,i - 1,j - 5,INSERT) ) {
5369 *reti = i - 1;
5370 *retj = j - 5;
5371 *retstate = INSERT;
5372 *retspecial = FALSE;
5373 if( cellscore != NULL) {
5374 *cellscore = cscore - (*h.access_main)(mat,i-1,j-5,INSERT);
5375 }
5376 return (*h.access_main)(mat,i - 1,j - 5,INSERT);
5377 }
5378 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
5379 if( temp == (*h.access_main)(mat,i - 1,j - 4,INSERT) ) {
5380 *reti = i - 1;
5381 *retj = j - 4;
5382 *retstate = INSERT;
5383 *retspecial = FALSE;
5384 if( cellscore != NULL) {
5385 *cellscore = cscore - (*h.access_main)(mat,i-1,j-4,INSERT);
5386 }
5387 return (*h.access_main)(mat,i - 1,j - 4,INSERT);
5388 }
5389 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
5390 if( temp == (*h.access_main)(mat,i - 1,j - 1,INSERT) ) {
5391 *reti = i - 1;
5392 *retj = j - 1;
5393 *retstate = INSERT;
5394 *retspecial = FALSE;
5395 if( cellscore != NULL) {
5396 *cellscore = cscore - (*h.access_main)(mat,i-1,j-1,INSERT);
5397 }
5398 return (*h.access_main)(mat,i - 1,j - 1,INSERT);
5399 }
5400 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
5401 if( temp == (*h.access_main)(mat,i - 1,j - 2,INSERT) ) {
5402 *reti = i - 1;
5403 *retj = j - 2;
5404 *retstate = INSERT;
5405 *retspecial = FALSE;
5406 if( cellscore != NULL) {
5407 *cellscore = cscore - (*h.access_main)(mat,i-1,j-2,INSERT);
5408 }
5409 return (*h.access_main)(mat,i - 1,j - 2,INSERT);
5410 }
5411 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
5412 if( temp == (*h.access_main)(mat,i - 1,j - 5,MATCH) ) {
5413 *reti = i - 1;
5414 *retj = j - 5;
5415 *retstate = MATCH;
5416 *retspecial = FALSE;
5417 if( cellscore != NULL) {
5418 *cellscore = cscore - (*h.access_main)(mat,i-1,j-5,MATCH);
5419 }
5420 return (*h.access_main)(mat,i - 1,j - 5,MATCH);
5421 }
5422 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
5423 if( temp == (*h.access_main)(mat,i - 1,j - 4,MATCH) ) {
5424 *reti = i - 1;
5425 *retj = j - 4;
5426 *retstate = MATCH;
5427 *retspecial = FALSE;
5428 if( cellscore != NULL) {
5429 *cellscore = cscore - (*h.access_main)(mat,i-1,j-4,MATCH);
5430 }
5431 return (*h.access_main)(mat,i - 1,j - 4,MATCH);
5432 }
5433 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
5434 if( temp == (*h.access_main)(mat,i - 1,j - 1,MATCH) ) {
5435 *reti = i - 1;
5436 *retj = j - 1;
5437 *retstate = MATCH;
5438 *retspecial = FALSE;
5439 if( cellscore != NULL) {
5440 *cellscore = cscore - (*h.access_main)(mat,i-1,j-1,MATCH);
5441 }
5442 return (*h.access_main)(mat,i - 1,j - 1,MATCH);
5443 }
5444 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
5445 if( temp == (*h.access_main)(mat,i - 1,j - 2,MATCH) ) {
5446 *reti = i - 1;
5447 *retj = j - 2;
5448 *retstate = MATCH;
5449 *retspecial = FALSE;
5450 if( cellscore != NULL) {
5451 *cellscore = cscore - (*h.access_main)(mat,i-1,j-2,MATCH);
5452 }
5453 return (*h.access_main)(mat,i - 1,j - 2,MATCH);
5454 }
5455 temp = cscore - ((mat->query->seg[i]->transition[GW_START2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
5456 if( temp == (*h.access_special)(mat,i - 1,j - 3,START) ) {
5457 *reti = i - 1;
5458 *retj = j - 3;
5459 *retstate = START;
5460 *retspecial = TRUE;
5461 if( cellscore != NULL) {
5462 *cellscore = cscore - (*h.access_special)(mat,i-1,j-3,START);
5463 }
5464 return (*h.access_main)(mat,i - 1,j - 3,START);
5465 }
5466 temp = cscore - ((mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
5467 if( temp == (*h.access_main)(mat,i - 1,j - 3,DELETE) ) {
5468 *reti = i - 1;
5469 *retj = j - 3;
5470 *retstate = DELETE;
5471 *retspecial = FALSE;
5472 if( cellscore != NULL) {
5473 *cellscore = cscore - (*h.access_main)(mat,i-1,j-3,DELETE);
5474 }
5475 return (*h.access_main)(mat,i - 1,j - 3,DELETE);
5476 }
5477 temp = cscore - ((mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
5478 if( temp == (*h.access_main)(mat,i - 1,j - 3,INSERT) ) {
5479 *reti = i - 1;
5480 *retj = j - 3;
5481 *retstate = INSERT;
5482 *retspecial = FALSE;
5483 if( cellscore != NULL) {
5484 *cellscore = cscore - (*h.access_main)(mat,i-1,j-3,INSERT);
5485 }
5486 return (*h.access_main)(mat,i - 1,j - 3,INSERT);
5487 }
5488 temp = cscore - ((mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
5489 if( temp == (*h.access_main)(mat,i - 1,j - 3,MATCH) ) {
5490 *reti = i - 1;
5491 *retj = j - 3;
5492 *retstate = MATCH;
5493 *retspecial = FALSE;
5494 if( cellscore != NULL) {
5495 *cellscore = cscore - (*h.access_main)(mat,i-1,j-3,MATCH);
5496 }
5497 return (*h.access_main)(mat,i - 1,j - 3,MATCH);
5498 }
5499 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
5500 return (-1);
5501 case INSERT :
5502 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
5503 if( temp == (*h.access_main)(mat,i - 0,j - 5,DELETE) ) {
5504 *reti = i - 0;
5505 *retj = j - 5;
5506 *retstate = DELETE;
5507 *retspecial = FALSE;
5508 if( cellscore != NULL) {
5509 *cellscore = cscore - (*h.access_main)(mat,i-0,j-5,DELETE);
5510 }
5511 return (*h.access_main)(mat,i - 0,j - 5,DELETE);
5512 }
5513 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
5514 if( temp == (*h.access_main)(mat,i - 0,j - 4,DELETE) ) {
5515 *reti = i - 0;
5516 *retj = j - 4;
5517 *retstate = DELETE;
5518 *retspecial = FALSE;
5519 if( cellscore != NULL) {
5520 *cellscore = cscore - (*h.access_main)(mat,i-0,j-4,DELETE);
5521 }
5522 return (*h.access_main)(mat,i - 0,j - 4,DELETE);
5523 }
5524 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
5525 if( temp == (*h.access_main)(mat,i - 0,j - 1,DELETE) ) {
5526 *reti = i - 0;
5527 *retj = j - 1;
5528 *retstate = DELETE;
5529 *retspecial = FALSE;
5530 if( cellscore != NULL) {
5531 *cellscore = cscore - (*h.access_main)(mat,i-0,j-1,DELETE);
5532 }
5533 return (*h.access_main)(mat,i - 0,j - 1,DELETE);
5534 }
5535 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
5536 if( temp == (*h.access_main)(mat,i - 0,j - 2,DELETE) ) {
5537 *reti = i - 0;
5538 *retj = j - 2;
5539 *retstate = DELETE;
5540 *retspecial = FALSE;
5541 if( cellscore != NULL) {
5542 *cellscore = cscore - (*h.access_main)(mat,i-0,j-2,DELETE);
5543 }
5544 return (*h.access_main)(mat,i - 0,j - 2,DELETE);
5545 }
5546 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
5547 if( temp == (*h.access_main)(mat,i - 0,j - 5,MATCH) ) {
5548 *reti = i - 0;
5549 *retj = j - 5;
5550 *retstate = MATCH;
5551 *retspecial = FALSE;
5552 if( cellscore != NULL) {
5553 *cellscore = cscore - (*h.access_main)(mat,i-0,j-5,MATCH);
5554 }
5555 return (*h.access_main)(mat,i - 0,j - 5,MATCH);
5556 }
5557 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
5558 if( temp == (*h.access_main)(mat,i - 0,j - 4,MATCH) ) {
5559 *reti = i - 0;
5560 *retj = j - 4;
5561 *retstate = MATCH;
5562 *retspecial = FALSE;
5563 if( cellscore != NULL) {
5564 *cellscore = cscore - (*h.access_main)(mat,i-0,j-4,MATCH);
5565 }
5566 return (*h.access_main)(mat,i - 0,j - 4,MATCH);
5567 }
5568 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
5569 if( temp == (*h.access_main)(mat,i - 0,j - 1,MATCH) ) {
5570 *reti = i - 0;
5571 *retj = j - 1;
5572 *retstate = MATCH;
5573 *retspecial = FALSE;
5574 if( cellscore != NULL) {
5575 *cellscore = cscore - (*h.access_main)(mat,i-0,j-1,MATCH);
5576 }
5577 return (*h.access_main)(mat,i - 0,j - 1,MATCH);
5578 }
5579 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
5580 if( temp == (*h.access_main)(mat,i - 0,j - 2,MATCH) ) {
5581 *reti = i - 0;
5582 *retj = j - 2;
5583 *retstate = MATCH;
5584 *retspecial = FALSE;
5585 if( cellscore != NULL) {
5586 *cellscore = cscore - (*h.access_main)(mat,i-0,j-2,MATCH);
5587 }
5588 return (*h.access_main)(mat,i - 0,j - 2,MATCH);
5589 }
5590 temp = cscore - (mat->cp->trans[PCD_INSERT_2_BASE]) - (0);
5591 if( temp == (*h.access_main)(mat,i - 0,j - 5,INSERT) ) {
5592 *reti = i - 0;
5593 *retj = j - 5;
5594 *retstate = INSERT;
5595 *retspecial = FALSE;
5596 if( cellscore != NULL) {
5597 *cellscore = cscore - (*h.access_main)(mat,i-0,j-5,INSERT);
5598 }
5599 return (*h.access_main)(mat,i - 0,j - 5,INSERT);
5600 }
5601 temp = cscore - (mat->cp->trans[PCD_INSERT_1_BASE]) - (0);
5602 if( temp == (*h.access_main)(mat,i - 0,j - 4,INSERT) ) {
5603 *reti = i - 0;
5604 *retj = j - 4;
5605 *retstate = INSERT;
5606 *retspecial = FALSE;
5607 if( cellscore != NULL) {
5608 *cellscore = cscore - (*h.access_main)(mat,i-0,j-4,INSERT);
5609 }
5610 return (*h.access_main)(mat,i - 0,j - 4,INSERT);
5611 }
5612 temp = cscore - (mat->cp->trans[PCD_DELETE_2_BASE]) - (0);
5613 if( temp == (*h.access_main)(mat,i - 0,j - 1,INSERT) ) {
5614 *reti = i - 0;
5615 *retj = j - 1;
5616 *retstate = INSERT;
5617 *retspecial = FALSE;
5618 if( cellscore != NULL) {
5619 *cellscore = cscore - (*h.access_main)(mat,i-0,j-1,INSERT);
5620 }
5621 return (*h.access_main)(mat,i - 0,j - 1,INSERT);
5622 }
5623 temp = cscore - (mat->cp->trans[PCD_DELETE_1_BASE]) - (0);
5624 if( temp == (*h.access_main)(mat,i - 0,j - 2,INSERT) ) {
5625 *reti = i - 0;
5626 *retj = j - 2;
5627 *retstate = INSERT;
5628 *retspecial = FALSE;
5629 if( cellscore != NULL) {
5630 *cellscore = cscore - (*h.access_main)(mat,i-0,j-2,INSERT);
5631 }
5632 return (*h.access_main)(mat,i - 0,j - 2,INSERT);
5633 }
5634 temp = cscore - ((mat->query->seg[i]->transition[GW_START2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
5635 if( temp == (*h.access_special)(mat,i - 0,j - 3,START) ) {
5636 *reti = i - 0;
5637 *retj = j - 3;
5638 *retstate = START;
5639 *retspecial = TRUE;
5640 if( cellscore != NULL) {
5641 *cellscore = cscore - (*h.access_special)(mat,i-0,j-3,START);
5642 }
5643 return (*h.access_main)(mat,i - 0,j - 3,START);
5644 }
5645 temp = cscore - ((mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
5646 if( temp == (*h.access_main)(mat,i - 0,j - 3,DELETE) ) {
5647 *reti = i - 0;
5648 *retj = j - 3;
5649 *retstate = DELETE;
5650 *retspecial = FALSE;
5651 if( cellscore != NULL) {
5652 *cellscore = cscore - (*h.access_main)(mat,i-0,j-3,DELETE);
5653 }
5654 return (*h.access_main)(mat,i - 0,j - 3,DELETE);
5655 }
5656 temp = cscore - ((mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
5657 if( temp == (*h.access_main)(mat,i - 0,j - 3,INSERT) ) {
5658 *reti = i - 0;
5659 *retj = j - 3;
5660 *retstate = INSERT;
5661 *retspecial = FALSE;
5662 if( cellscore != NULL) {
5663 *cellscore = cscore - (*h.access_main)(mat,i-0,j-3,INSERT);
5664 }
5665 return (*h.access_main)(mat,i - 0,j - 3,INSERT);
5666 }
5667 temp = cscore - ((mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)])) - (0);
5668 if( temp == (*h.access_main)(mat,i - 0,j - 3,MATCH) ) {
5669 *reti = i - 0;
5670 *retj = j - 3;
5671 *retstate = MATCH;
5672 *retspecial = FALSE;
5673 if( cellscore != NULL) {
5674 *cellscore = cscore - (*h.access_main)(mat,i-0,j-3,MATCH);
5675 }
5676 return (*h.access_main)(mat,i - 0,j - 3,MATCH);
5677 }
5678 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
5679 return (-1);
5680 case DELETE :
5681 temp = cscore - (mat->query->seg[i]->transition[GW_START2DELETE]) - (0);
5682 if( temp == (*h.access_special)(mat,i - 1,j - 0,START) ) {
5683 *reti = i - 1;
5684 *retj = j - 0;
5685 *retstate = START;
5686 *retspecial = TRUE;
5687 if( cellscore != NULL) {
5688 *cellscore = cscore - (*h.access_special)(mat,i-1,j-0,START);
5689 }
5690 return (*h.access_main)(mat,i - 1,j - 0,START);
5691 }
5692 temp = cscore - (mat->query->seg[i]->transition[GW_DELETE2DELETE]) - (0);
5693 if( temp == (*h.access_main)(mat,i - 1,j - 0,DELETE) ) {
5694 *reti = i - 1;
5695 *retj = j - 0;
5696 *retstate = DELETE;
5697 *retspecial = FALSE;
5698 if( cellscore != NULL) {
5699 *cellscore = cscore - (*h.access_main)(mat,i-1,j-0,DELETE);
5700 }
5701 return (*h.access_main)(mat,i - 1,j - 0,DELETE);
5702 }
5703 temp = cscore - (mat->query->seg[i]->transition[GW_INSERT2DELETE]) - (0);
5704 if( temp == (*h.access_main)(mat,i - 1,j - 0,INSERT) ) {
5705 *reti = i - 1;
5706 *retj = j - 0;
5707 *retstate = INSERT;
5708 *retspecial = FALSE;
5709 if( cellscore != NULL) {
5710 *cellscore = cscore - (*h.access_main)(mat,i-1,j-0,INSERT);
5711 }
5712 return (*h.access_main)(mat,i - 1,j - 0,INSERT);
5713 }
5714 temp = cscore - (mat->query->seg[i]->transition[GW_MATCH2DELETE]) - (0);
5715 if( temp == (*h.access_main)(mat,i - 1,j - 0,MATCH) ) {
5716 *reti = i - 1;
5717 *retj = j - 0;
5718 *retstate = MATCH;
5719 *retspecial = FALSE;
5720 if( cellscore != NULL) {
5721 *cellscore = cscore - (*h.access_main)(mat,i-1,j-0,MATCH);
5722 }
5723 return (*h.access_main)(mat,i - 1,j - 0,MATCH);
5724 }
5725 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
5726 return (-1);
5727 default:
5728 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found!",i,j,state);
5729 return (-1);
5730 } /* end of Switch state */
5731 }
5732
5733
5734 /* Function: max_calc_special_EstWise3(mat,i,j,state,isspecial,reti,retj,retstate,retspecial,cellscore,h)
5735 *
5736 * Descrip: No Description
5737 *
5738 * Arg: mat [UNKN ] Undocumented argument [EstWise3 *]
5739 * Arg: i [UNKN ] Undocumented argument [int]
5740 * Arg: j [UNKN ] Undocumented argument [int]
5741 * Arg: state [UNKN ] Undocumented argument [int]
5742 * Arg: isspecial [UNKN ] Undocumented argument [boolean]
5743 * Arg: reti [UNKN ] Undocumented argument [int *]
5744 * Arg: retj [UNKN ] Undocumented argument [int *]
5745 * Arg: retstate [UNKN ] Undocumented argument [int *]
5746 * Arg: retspecial [UNKN ] Undocumented argument [boolean *]
5747 * Arg: cellscore [UNKN ] Undocumented argument [int *]
5748 * Arg: h [UNKN ] Undocumented argument [EstWise3_access_func_holder]
5749 *
5750 * Return [UNKN ] Undocumented return value [int]
5751 *
5752 */
max_calc_special_EstWise3(EstWise3 * mat,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore,EstWise3_access_func_holder h)5753 int max_calc_special_EstWise3(EstWise3 * mat,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore,EstWise3_access_func_holder h)
5754 {
5755 register int temp;
5756 register int cscore;
5757
5758
5759 *reti = (*retj) = (*retstate) = EstWise3_READ_OFF_ERROR;
5760
5761
5762 if( j < 0 || j > mat->target->seq->len) {
5763 warn("In EstWise3 matrix special read off - out of bounds on matrix [j is %d in special]",j);
5764 return -1;
5765 }
5766
5767
5768 cscore = (*h.access_special)(mat,i,j,state);
5769 switch(state) { /*switch on special states*/
5770 case START :
5771 case END :
5772 /* source DELETE is from main matrix */
5773 for(i= mat->query->len-1;i >= 0 ;i--) { /*for i >= 0*/
5774 temp = cscore - (mat->query->seg[i]->transition[GW_DELETE2END]) - (0);
5775 if( temp == (*h.access_main)(mat,i - 0,j - 0,DELETE) ) {
5776 *reti = i - 0;
5777 *retj = j - 0;
5778 *retstate = DELETE;
5779 *retspecial = FALSE;
5780 if( cellscore != NULL) {
5781 *cellscore = cscore - (*h.access_main)(mat,i-0,j-0,DELETE);
5782 }
5783 return (*h.access_main)(mat,i - 0,j - 0,DELETE) ;
5784 }
5785 } /* end of for i >= 0 */
5786 /* source INSERT is from main matrix */
5787 for(i= mat->query->len-1;i >= 0 ;i--) { /*for i >= 0*/
5788 temp = cscore - (mat->query->seg[i]->transition[GW_INSERT2END]) - (0);
5789 if( temp == (*h.access_main)(mat,i - 0,j - 0,INSERT) ) {
5790 *reti = i - 0;
5791 *retj = j - 0;
5792 *retstate = INSERT;
5793 *retspecial = FALSE;
5794 if( cellscore != NULL) {
5795 *cellscore = cscore - (*h.access_main)(mat,i-0,j-0,INSERT);
5796 }
5797 return (*h.access_main)(mat,i - 0,j - 0,INSERT) ;
5798 }
5799 } /* end of for i >= 0 */
5800 /* source MATCH is from main matrix */
5801 for(i= mat->query->len-1;i >= 0 ;i--) { /*for i >= 0*/
5802 temp = cscore - (mat->query->seg[i]->transition[GW_MATCH2END]) - (0);
5803 if( temp == (*h.access_main)(mat,i - 0,j - 0,MATCH) ) {
5804 *reti = i - 0;
5805 *retj = j - 0;
5806 *retstate = MATCH;
5807 *retspecial = FALSE;
5808 if( cellscore != NULL) {
5809 *cellscore = cscore - (*h.access_main)(mat,i-0,j-0,MATCH);
5810 }
5811 return (*h.access_main)(mat,i - 0,j - 0,MATCH) ;
5812 }
5813 } /* end of for i >= 0 */
5814 default:
5815 warn("Major problem (!) - in EstWise3 read off, position %d,%d state %d no source found dropped into default on source switch!",i,j,state);
5816 return (-1);
5817 } /* end of switch on special states */
5818 }
5819
5820
5821 /* Function: calculate_EstWise3(mat)
5822 *
5823 * Descrip: This function calculates the EstWise3 matrix when in explicit mode
5824 * To allocate the matrix use /allocate_Expl_EstWise3
5825 *
5826 *
5827 * Arg: mat [UNKN ] EstWise3 which contains explicit basematrix memory [EstWise3 *]
5828 *
5829 * Return [UNKN ] Undocumented return value [boolean]
5830 *
5831 */
calculate_EstWise3(EstWise3 * mat)5832 boolean calculate_EstWise3(EstWise3 * mat)
5833 {
5834 int i;
5835 int j;
5836 int leni;
5837 int lenj;
5838 int tot;
5839 int num;
5840
5841
5842 if( mat->basematrix->type != BASEMATRIX_TYPE_EXPLICIT ) {
5843 warn("in calculate_EstWise3, passed a non Explicit matrix type, cannot calculate!");
5844 return FALSE;
5845 }
5846
5847
5848 leni = mat->leni;
5849 lenj = mat->lenj;
5850 tot = leni * lenj;
5851 num = 0;
5852
5853
5854 start_reporting("EstWise3 Matrix calculation: ");
5855 for(j=0;j<lenj;j++) {
5856 auto int score;
5857 auto int temp;
5858 for(i=0;i<leni;i++) {
5859 if( num%1000 == 0 )
5860 log_full_error(REPORT,0,"[%7d] Cells %2d%%%%",num,num*100/tot);
5861 num++;
5862
5863
5864 /* For state MATCH */
5865 /* setting first movement to score */
5866 score = EstWise3_EXPL_MATRIX(mat,i-1,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
5867 /* From state INSERT to state MATCH */
5868 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
5869 if( temp > score ) {
5870 score = temp;
5871 }
5872 /* From state DELETE to state MATCH */
5873 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
5874 if( temp > score ) {
5875 score = temp;
5876 }
5877 /* From state START to state MATCH */
5878 temp = EstWise3_EXPL_SPECIAL(mat,i-1,j-3,START) + (mat->query->seg[i]->transition[GW_START2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
5879 if( temp > score ) {
5880 score = temp;
5881 }
5882 /* From state MATCH to state MATCH */
5883 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
5884 if( temp > score ) {
5885 score = temp;
5886 }
5887 /* From state MATCH to state MATCH */
5888 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
5889 if( temp > score ) {
5890 score = temp;
5891 }
5892 /* From state MATCH to state MATCH */
5893 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
5894 if( temp > score ) {
5895 score = temp;
5896 }
5897 /* From state MATCH to state MATCH */
5898 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
5899 if( temp > score ) {
5900 score = temp;
5901 }
5902 /* From state INSERT to state MATCH */
5903 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
5904 if( temp > score ) {
5905 score = temp;
5906 }
5907 /* From state INSERT to state MATCH */
5908 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
5909 if( temp > score ) {
5910 score = temp;
5911 }
5912 /* From state INSERT to state MATCH */
5913 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
5914 if( temp > score ) {
5915 score = temp;
5916 }
5917 /* From state INSERT to state MATCH */
5918 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
5919 if( temp > score ) {
5920 score = temp;
5921 }
5922 /* From state DELETE to state MATCH */
5923 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
5924 if( temp > score ) {
5925 score = temp;
5926 }
5927 /* From state DELETE to state MATCH */
5928 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
5929 if( temp > score ) {
5930 score = temp;
5931 }
5932 /* From state DELETE to state MATCH */
5933 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
5934 if( temp > score ) {
5935 score = temp;
5936 }
5937 /* From state DELETE to state MATCH */
5938 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
5939 if( temp > score ) {
5940 score = temp;
5941 }
5942
5943
5944 /* Ok - finished max calculation for MATCH */
5945 /* Add any movement independant score and put away */
5946 EstWise3_EXPL_MATRIX(mat,i,j,MATCH) = score;
5947
5948
5949 /* state MATCH is a source for special END */
5950 temp = score + (mat->query->seg[i]->transition[GW_MATCH2END]) + (0) ;
5951 if( temp > EstWise3_EXPL_SPECIAL(mat,i,j,END) ) {
5952 EstWise3_EXPL_SPECIAL(mat,i,j,END) = temp;
5953 }
5954
5955
5956
5957
5958 /* Finished calculating state MATCH */
5959
5960
5961 /* For state INSERT */
5962 /* setting first movement to score */
5963 score = EstWise3_EXPL_MATRIX(mat,i-0,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
5964 /* From state INSERT to state INSERT */
5965 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
5966 if( temp > score ) {
5967 score = temp;
5968 }
5969 /* From state DELETE to state INSERT */
5970 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
5971 if( temp > score ) {
5972 score = temp;
5973 }
5974 /* From state START to state INSERT */
5975 temp = EstWise3_EXPL_SPECIAL(mat,i-0,j-3,START) + (mat->query->seg[i]->transition[GW_START2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
5976 if( temp > score ) {
5977 score = temp;
5978 }
5979 /* From state INSERT to state INSERT */
5980 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
5981 if( temp > score ) {
5982 score = temp;
5983 }
5984 /* From state INSERT to state INSERT */
5985 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
5986 if( temp > score ) {
5987 score = temp;
5988 }
5989 /* From state INSERT to state INSERT */
5990 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
5991 if( temp > score ) {
5992 score = temp;
5993 }
5994 /* From state INSERT to state INSERT */
5995 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
5996 if( temp > score ) {
5997 score = temp;
5998 }
5999 /* From state MATCH to state INSERT */
6000 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
6001 if( temp > score ) {
6002 score = temp;
6003 }
6004 /* From state MATCH to state INSERT */
6005 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
6006 if( temp > score ) {
6007 score = temp;
6008 }
6009 /* From state MATCH to state INSERT */
6010 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
6011 if( temp > score ) {
6012 score = temp;
6013 }
6014 /* From state MATCH to state INSERT */
6015 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
6016 if( temp > score ) {
6017 score = temp;
6018 }
6019 /* From state DELETE to state INSERT */
6020 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
6021 if( temp > score ) {
6022 score = temp;
6023 }
6024 /* From state DELETE to state INSERT */
6025 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
6026 if( temp > score ) {
6027 score = temp;
6028 }
6029 /* From state DELETE to state INSERT */
6030 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
6031 if( temp > score ) {
6032 score = temp;
6033 }
6034 /* From state DELETE to state INSERT */
6035 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
6036 if( temp > score ) {
6037 score = temp;
6038 }
6039
6040
6041 /* Ok - finished max calculation for INSERT */
6042 /* Add any movement independant score and put away */
6043 EstWise3_EXPL_MATRIX(mat,i,j,INSERT) = score;
6044
6045
6046 /* state INSERT is a source for special END */
6047 temp = score + (mat->query->seg[i]->transition[GW_INSERT2END]) + (0) ;
6048 if( temp > EstWise3_EXPL_SPECIAL(mat,i,j,END) ) {
6049 EstWise3_EXPL_SPECIAL(mat,i,j,END) = temp;
6050 }
6051
6052
6053
6054
6055 /* Finished calculating state INSERT */
6056
6057
6058 /* For state DELETE */
6059 /* setting first movement to score */
6060 score = EstWise3_EXPL_MATRIX(mat,i-1,j-0,MATCH) + mat->query->seg[i]->transition[GW_MATCH2DELETE];
6061 /* From state INSERT to state DELETE */
6062 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-0,INSERT) + mat->query->seg[i]->transition[GW_INSERT2DELETE];
6063 if( temp > score ) {
6064 score = temp;
6065 }
6066 /* From state DELETE to state DELETE */
6067 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-0,DELETE) + mat->query->seg[i]->transition[GW_DELETE2DELETE];
6068 if( temp > score ) {
6069 score = temp;
6070 }
6071 /* From state START to state DELETE */
6072 temp = EstWise3_EXPL_SPECIAL(mat,i-1,j-0,START) + mat->query->seg[i]->transition[GW_START2DELETE];
6073 if( temp > score ) {
6074 score = temp;
6075 }
6076
6077
6078 /* Ok - finished max calculation for DELETE */
6079 /* Add any movement independant score and put away */
6080 EstWise3_EXPL_MATRIX(mat,i,j,DELETE) = score;
6081
6082
6083 /* state DELETE is a source for special END */
6084 temp = score + (mat->query->seg[i]->transition[GW_DELETE2END]) + (0) ;
6085 if( temp > EstWise3_EXPL_SPECIAL(mat,i,j,END) ) {
6086 EstWise3_EXPL_SPECIAL(mat,i,j,END) = temp;
6087 }
6088
6089
6090
6091
6092 /* Finished calculating state DELETE */
6093 }
6094
6095
6096 /* Special state START has no special to special movements */
6097
6098
6099 /* Special state END has no special to special movements */
6100 }
6101 stop_reporting();
6102 return TRUE;
6103 }
6104
6105
6106 /* Function: calculate_dpenv_EstWise3(mat,dpenv)
6107 *
6108 * Descrip: This function calculates the EstWise3 matrix when in explicit mode, subject to the envelope
6109 *
6110 *
6111 * Arg: mat [UNKN ] EstWise3 which contains explicit basematrix memory [EstWise3 *]
6112 * Arg: dpenv [UNKN ] Undocumented argument [DPEnvelope *]
6113 *
6114 * Return [UNKN ] Undocumented return value [boolean]
6115 *
6116 */
calculate_dpenv_EstWise3(EstWise3 * mat,DPEnvelope * dpenv)6117 boolean calculate_dpenv_EstWise3(EstWise3 * mat,DPEnvelope * dpenv)
6118 {
6119 int i;
6120 int j;
6121 int k;
6122 int starti;
6123 int startj;
6124 int endi;
6125 int endj;
6126 int tot;
6127 int num;
6128 int should_calc;
6129
6130
6131 if( mat->basematrix->type != BASEMATRIX_TYPE_EXPLICIT ) {
6132 warn("in calculate_EstWise3, passed a non Explicit matrix type, cannot calculate!");
6133 return FALSE;
6134 }
6135
6136
6137 prepare_DPEnvelope(dpenv);
6138 starti = dpenv->starti;
6139 if( starti < 0 )
6140 starti = 0;
6141 startj = dpenv->startj;
6142 if( startj < 0 )
6143 startj = 0;
6144 endi = dpenv->endi;
6145 if( endi > mat->leni )
6146 endi = mat->leni;
6147 endj = dpenv->endj;
6148 if( endj > mat->lenj )
6149 endj = mat->lenj;
6150 tot = (endi-starti) * (endj-startj);
6151 num = 0;
6152
6153
6154 for(j=startj-5;j<endj;j++) {
6155 for(i=1;i<mat->leni;i++) {
6156 EstWise3_EXPL_MATRIX(mat,i,j,MATCH) = NEGI;
6157 EstWise3_EXPL_MATRIX(mat,i,j,INSERT) = NEGI;
6158 EstWise3_EXPL_MATRIX(mat,i,j,DELETE) = NEGI;
6159 }
6160 }
6161 for(j=-5;j<mat->lenj;j++) {
6162 EstWise3_EXPL_SPECIAL(mat,i,j,START) = 0;
6163 EstWise3_EXPL_SPECIAL(mat,i,j,END) = NEGI;
6164 }
6165
6166
6167 start_reporting("EstWise3 Matrix calculation: ");
6168 for(j=startj;j<endj;j++) {
6169 auto int score;
6170 auto int temp;
6171 for(i=starti;i<endi;i++) {
6172 /* Check if is in envelope - code identical to is_in_DPEnvelope, but aggressively inlined here for speed */
6173 should_calc = 0;
6174 for(k=0;k<dpenv->len;k++) {
6175 auto DPUnit * u;
6176 u = dpenv->dpu[k];
6177 switch(u->type) {
6178 case DPENV_RECT :
6179 if( i >= u->starti && j >= u->startj && i <= (u->starti+u->height) && j <= (u->startj+u->length))
6180 should_calc = 1;
6181 break;
6182 case DPENV_DIAG :
6183 if( abs( (i-j) - (u->starti-u->startj)) <= u->height && i+j >= u->starti+u->startj && i+j+u->length >= u->starti+u->startj)
6184 should_calc = 1;
6185 break;
6186 }
6187 if( should_calc == 1 )
6188 break;
6189 }
6190 if( should_calc == 0) {
6191 EstWise3_EXPL_MATRIX(mat,i,j,MATCH) = NEGI;
6192 EstWise3_EXPL_MATRIX(mat,i,j,INSERT) = NEGI;
6193 EstWise3_EXPL_MATRIX(mat,i,j,DELETE) = NEGI;
6194 continue;
6195 }
6196
6197
6198 if( num%1000 == 0 )
6199 log_full_error(REPORT,0,"[%7d] Cells %2d%%%%",num,num*100/tot);
6200 num++;
6201
6202
6203 /* For state MATCH */
6204 /* setting first movement to score */
6205 score = EstWise3_EXPL_MATRIX(mat,i-1,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
6206 /* From state INSERT to state MATCH */
6207 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
6208 if( temp > score ) {
6209 score = temp;
6210 }
6211 /* From state DELETE to state MATCH */
6212 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
6213 if( temp > score ) {
6214 score = temp;
6215 }
6216 /* From state START to state MATCH */
6217 temp = EstWise3_EXPL_SPECIAL(mat,i-1,j-3,START) + (mat->query->seg[i]->transition[GW_START2MATCH]+mat->query->seg[i]->match[CSEQ_CDNA_CODON(mat->target,j)]);
6218 if( temp > score ) {
6219 score = temp;
6220 }
6221 /* From state MATCH to state MATCH */
6222 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
6223 if( temp > score ) {
6224 score = temp;
6225 }
6226 /* From state MATCH to state MATCH */
6227 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
6228 if( temp > score ) {
6229 score = temp;
6230 }
6231 /* From state MATCH to state MATCH */
6232 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
6233 if( temp > score ) {
6234 score = temp;
6235 }
6236 /* From state MATCH to state MATCH */
6237 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
6238 if( temp > score ) {
6239 score = temp;
6240 }
6241 /* From state INSERT to state MATCH */
6242 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
6243 if( temp > score ) {
6244 score = temp;
6245 }
6246 /* From state INSERT to state MATCH */
6247 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
6248 if( temp > score ) {
6249 score = temp;
6250 }
6251 /* From state INSERT to state MATCH */
6252 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
6253 if( temp > score ) {
6254 score = temp;
6255 }
6256 /* From state INSERT to state MATCH */
6257 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
6258 if( temp > score ) {
6259 score = temp;
6260 }
6261 /* From state DELETE to state MATCH */
6262 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
6263 if( temp > score ) {
6264 score = temp;
6265 }
6266 /* From state DELETE to state MATCH */
6267 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
6268 if( temp > score ) {
6269 score = temp;
6270 }
6271 /* From state DELETE to state MATCH */
6272 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
6273 if( temp > score ) {
6274 score = temp;
6275 }
6276 /* From state DELETE to state MATCH */
6277 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
6278 if( temp > score ) {
6279 score = temp;
6280 }
6281
6282
6283 /* Ok - finished max calculation for MATCH */
6284 /* Add any movement independant score and put away */
6285 EstWise3_EXPL_MATRIX(mat,i,j,MATCH) = score;
6286
6287
6288 /* state MATCH is a source for special END */
6289 temp = score + (mat->query->seg[i]->transition[GW_MATCH2END]) + (0) ;
6290 if( temp > EstWise3_EXPL_SPECIAL(mat,i,j,END) ) {
6291 EstWise3_EXPL_SPECIAL(mat,i,j,END) = temp;
6292 }
6293
6294
6295
6296
6297 /* Finished calculating state MATCH */
6298
6299
6300 /* For state INSERT */
6301 /* setting first movement to score */
6302 score = EstWise3_EXPL_MATRIX(mat,i-0,j-3,MATCH) + (mat->query->seg[i]->transition[GW_MATCH2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
6303 /* From state INSERT to state INSERT */
6304 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-3,INSERT) + (mat->query->seg[i]->transition[GW_INSERT2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
6305 if( temp > score ) {
6306 score = temp;
6307 }
6308 /* From state DELETE to state INSERT */
6309 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-3,DELETE) + (mat->query->seg[i]->transition[GW_DELETE2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
6310 if( temp > score ) {
6311 score = temp;
6312 }
6313 /* From state START to state INSERT */
6314 temp = EstWise3_EXPL_SPECIAL(mat,i-0,j-3,START) + (mat->query->seg[i]->transition[GW_START2INSERT]+mat->query->seg[i]->insert[CSEQ_CDNA_CODON(mat->target,j)]);
6315 if( temp > score ) {
6316 score = temp;
6317 }
6318 /* From state INSERT to state INSERT */
6319 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-2,INSERT) + mat->cp->trans[PCD_DELETE_1_BASE];
6320 if( temp > score ) {
6321 score = temp;
6322 }
6323 /* From state INSERT to state INSERT */
6324 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-1,INSERT) + mat->cp->trans[PCD_DELETE_2_BASE];
6325 if( temp > score ) {
6326 score = temp;
6327 }
6328 /* From state INSERT to state INSERT */
6329 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-4,INSERT) + mat->cp->trans[PCD_INSERT_1_BASE];
6330 if( temp > score ) {
6331 score = temp;
6332 }
6333 /* From state INSERT to state INSERT */
6334 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-5,INSERT) + mat->cp->trans[PCD_INSERT_2_BASE];
6335 if( temp > score ) {
6336 score = temp;
6337 }
6338 /* From state MATCH to state INSERT */
6339 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-2,MATCH) + mat->cp->trans[PCD_DELETE_1_BASE];
6340 if( temp > score ) {
6341 score = temp;
6342 }
6343 /* From state MATCH to state INSERT */
6344 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-1,MATCH) + mat->cp->trans[PCD_DELETE_2_BASE];
6345 if( temp > score ) {
6346 score = temp;
6347 }
6348 /* From state MATCH to state INSERT */
6349 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-4,MATCH) + mat->cp->trans[PCD_INSERT_1_BASE];
6350 if( temp > score ) {
6351 score = temp;
6352 }
6353 /* From state MATCH to state INSERT */
6354 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-5,MATCH) + mat->cp->trans[PCD_INSERT_2_BASE];
6355 if( temp > score ) {
6356 score = temp;
6357 }
6358 /* From state DELETE to state INSERT */
6359 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-2,DELETE) + mat->cp->trans[PCD_DELETE_1_BASE];
6360 if( temp > score ) {
6361 score = temp;
6362 }
6363 /* From state DELETE to state INSERT */
6364 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-1,DELETE) + mat->cp->trans[PCD_DELETE_2_BASE];
6365 if( temp > score ) {
6366 score = temp;
6367 }
6368 /* From state DELETE to state INSERT */
6369 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-4,DELETE) + mat->cp->trans[PCD_INSERT_1_BASE];
6370 if( temp > score ) {
6371 score = temp;
6372 }
6373 /* From state DELETE to state INSERT */
6374 temp = EstWise3_EXPL_MATRIX(mat,i-0,j-5,DELETE) + mat->cp->trans[PCD_INSERT_2_BASE];
6375 if( temp > score ) {
6376 score = temp;
6377 }
6378
6379
6380 /* Ok - finished max calculation for INSERT */
6381 /* Add any movement independant score and put away */
6382 EstWise3_EXPL_MATRIX(mat,i,j,INSERT) = score;
6383
6384
6385 /* state INSERT is a source for special END */
6386 temp = score + (mat->query->seg[i]->transition[GW_INSERT2END]) + (0) ;
6387 if( temp > EstWise3_EXPL_SPECIAL(mat,i,j,END) ) {
6388 EstWise3_EXPL_SPECIAL(mat,i,j,END) = temp;
6389 }
6390
6391
6392
6393
6394 /* Finished calculating state INSERT */
6395
6396
6397 /* For state DELETE */
6398 /* setting first movement to score */
6399 score = EstWise3_EXPL_MATRIX(mat,i-1,j-0,MATCH) + mat->query->seg[i]->transition[GW_MATCH2DELETE];
6400 /* From state INSERT to state DELETE */
6401 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-0,INSERT) + mat->query->seg[i]->transition[GW_INSERT2DELETE];
6402 if( temp > score ) {
6403 score = temp;
6404 }
6405 /* From state DELETE to state DELETE */
6406 temp = EstWise3_EXPL_MATRIX(mat,i-1,j-0,DELETE) + mat->query->seg[i]->transition[GW_DELETE2DELETE];
6407 if( temp > score ) {
6408 score = temp;
6409 }
6410 /* From state START to state DELETE */
6411 temp = EstWise3_EXPL_SPECIAL(mat,i-1,j-0,START) + mat->query->seg[i]->transition[GW_START2DELETE];
6412 if( temp > score ) {
6413 score = temp;
6414 }
6415
6416
6417 /* Ok - finished max calculation for DELETE */
6418 /* Add any movement independant score and put away */
6419 EstWise3_EXPL_MATRIX(mat,i,j,DELETE) = score;
6420
6421
6422 /* state DELETE is a source for special END */
6423 temp = score + (mat->query->seg[i]->transition[GW_DELETE2END]) + (0) ;
6424 if( temp > EstWise3_EXPL_SPECIAL(mat,i,j,END) ) {
6425 EstWise3_EXPL_SPECIAL(mat,i,j,END) = temp;
6426 }
6427
6428
6429
6430
6431 /* Finished calculating state DELETE */
6432 }
6433
6434
6435 /* Special state START has no special to special movements */
6436
6437
6438 /* Special state END has no special to special movements */
6439 }
6440 stop_reporting();
6441 return TRUE;
6442 }
6443
6444
6445 /* Function: EstWise3_alloc(void)
6446 *
6447 * Descrip: Allocates structure: assigns defaults if given
6448 *
6449 *
6450 *
6451 * Return [UNKN ] Undocumented return value [EstWise3 *]
6452 *
6453 */
EstWise3_alloc(void)6454 EstWise3 * EstWise3_alloc(void)
6455 {
6456 EstWise3 * out; /* out is exported at end of function */
6457
6458
6459 /* call ckalloc and see if NULL */
6460 if((out=(EstWise3 *) ckalloc (sizeof(EstWise3))) == NULL) {
6461 warn("EstWise3_alloc failed ");
6462 return NULL; /* calling function should respond! */
6463 }
6464 out->dynamite_hard_link = 1;
6465 #ifdef PTHREAD
6466 pthread_mutex_init(&(out->dynamite_mutex),NULL);
6467 #endif
6468 out->basematrix = NULL;
6469 out->shatter = NULL;
6470 out->leni = 0;
6471 out->lenj = 0;
6472
6473
6474 return out;
6475 }
6476
6477
6478 /* Function: free_EstWise3(obj)
6479 *
6480 * Descrip: Free Function: removes the memory held by obj
6481 * Will chain up to owned members and clear all lists
6482 *
6483 *
6484 * Arg: obj [UNKN ] Object that is free'd [EstWise3 *]
6485 *
6486 * Return [UNKN ] Undocumented return value [EstWise3 *]
6487 *
6488 */
free_EstWise3(EstWise3 * obj)6489 EstWise3 * free_EstWise3(EstWise3 * obj)
6490 {
6491 int return_early = 0;
6492
6493
6494 if( obj == NULL) {
6495 warn("Attempting to free a NULL pointer to a EstWise3 obj. Should be trappable");
6496 return NULL;
6497 }
6498
6499
6500 #ifdef PTHREAD
6501 assert(pthread_mutex_lock(&(obj->dynamite_mutex)) == 0);
6502 #endif
6503 if( obj->dynamite_hard_link > 1) {
6504 return_early = 1;
6505 obj->dynamite_hard_link--;
6506 }
6507 #ifdef PTHREAD
6508 assert(pthread_mutex_unlock(&(obj->dynamite_mutex)) == 0);
6509 #endif
6510 if( return_early == 1)
6511 return NULL;
6512 if( obj->basematrix != NULL)
6513 free_BaseMatrix(obj->basematrix);
6514 if( obj->shatter != NULL)
6515 free_ShatterMatrix(obj->shatter);
6516 /* obj->query is linked in */
6517 /* obj->target is linked in */
6518 /* obj->cp is linked in */
6519
6520
6521 ckfree(obj);
6522 return NULL;
6523 }
6524
6525
6526
6527
6528
6529 #ifdef _cplusplus
6530 }
6531 #endif
6532