1 /* @source ensqcalignment *****************************************************
2 **
3 ** Ensembl Quality Check Alignment functions
4 **
5 ** @author Copyright (C) 1999 Ensembl Developers
6 ** @author Copyright (C) 2006 Michael K. Schuster
7 ** @version $Revision: 1.42 $
8 ** @modified 2009 by Alan Bleasby for incorporation into EMBOSS core
9 ** @modified $Date: 2013/02/17 13:02:11 $ by $Author: mks $
10 ** @@
11 **
12 ** This library is free software; you can redistribute it and/or
13 ** modify it under the terms of the GNU Lesser General Public
14 ** License as published by the Free Software Foundation; either
15 ** version 2.1 of the License, or (at your option) any later version.
16 **
17 ** This library is distributed in the hope that it will be useful,
18 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 ** Lesser General Public License for more details.
21 **
22 ** You should have received a copy of the GNU Lesser General Public
23 ** License along with this library; if not, write to the Free Software
24 ** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
25 ** MA 02110-1301, USA.
26 **
27 ******************************************************************************/
28
29 /* ========================================================================= */
30 /* ============================= include files ============================= */
31 /* ========================================================================= */
32
33 #include "ensqcalignment.h"
34
35
36
37
38 /* ========================================================================= */
39 /* =============================== constants =============================== */
40 /* ========================================================================= */
41
42
43
44
45 /* ========================================================================= */
46 /* =========================== global variables ============================ */
47 /* ========================================================================= */
48
49
50
51
52 /* ========================================================================= */
53 /* ============================= private data ============================== */
54 /* ========================================================================= */
55
56
57
58
59 /* ========================================================================= */
60 /* =========================== private constants =========================== */
61 /* ========================================================================= */
62
63 #if AJFALSE
64 /* @conststatic qcalignmentKQueryCoveragePropertiesDnaDna *********************
65 **
66 ** DNA to DNA Query Coverage Scoring Schema
67 **
68 ** 5'-terminus 3'-terminus
69 **
70 ** 2**n score 2**n score
71 ** - 0 - - 0
72 ** 0 1 alignment 0 1
73 ** - 0 non-matching region - 0
74 ** 2 4 shorter region 1 2
75 ** 4 16 longer region 3 8
76 ** 6 64 non-matching edge 5 32
77 ** 8 256 shorter edge 7 128
78 ** 10 1024 longer edge 9 512
79 ** 12 4096 perfect 11 2048
80 ** 13 8192 identity >= threshold 13 8192
81 **
82 ******************************************************************************/
83
84 static const char *qcalignmentKQueryCoveragePropertiesDnaDna[] =
85 {
86 "No Alignment",
87 "Alignment",
88 "3' shorter region",
89 "5' shorter region",
90 "3' longer region",
91 "5' longer region",
92 "3' non-matching edge",
93 "5' non-matching edge",
94 "3' shorter edge",
95 "5' shorter edge",
96 "3' longer edge",
97 "5' longer edge",
98 "3' perfect",
99 "5' perfect",
100 "Identity Threshold",
101 "Sum",
102 (const char *) NULL
103 };
104 #endif /* AJFALSE */
105
106
107
108
109 #if AJFALSE
110 /* @conststatic qcalignmentKQueryCoveragePropertiesDnaGenome ******************
111 **
112 ** cDNA to Genome Query Coverage Scoring Schema
113 **
114 ** The query coverage score reflects individual alignment properties by
115 ** adding 2**n, where n increases with the quality of the alignment. The
116 ** following alignment properties are currently scored for query
117 ** sequences of type 'dna'.
118 **
119 ** 5'-terminus 3'-terminus
120 **
121 ** 2**n score 2**n score
122 ** - 0 alignment is missing - 0
123 ** 0 1 alignment is there 0 1
124 ** - 0 non-matching ends - 0
125 ** 2 4 shorter ends 1 2
126 ** 4 16 edge <= threshold 3 8
127 ** 6 64 perfect 5 32
128 ** 7 128 identity >= threshold 7 128
129 **
130 ******************************************************************************/
131
132 static const char *qcalignmentKQueryCoveragePropertiesDnaGenome[] =
133 {
134 "No Alignment",
135 "Alignment",
136 "3' shorter",
137 "5' shorter",
138 "3' tolerance",
139 "5' tolerance",
140 "3' perfect",
141 "5' perfect",
142 "Identity Threshold",
143 "Coverage Threshold",
144 "Sum",
145 (const char *) NULL
146 };
147 #endif /* AJFALSE */
148
149
150
151
152 #if AJFALSE
153 /* @conststatic qcalignmentKQueryCoveragePropertiesProteinGenome **************
154 **
155 ** Protein to Genome Query Coverage Scoring Schema
156 **
157 ** The query coverage score reflects individual alignment properties by
158 ** adding 2**n, where n increases with the quality of the alignment. The
159 ** following alignment properties are currently scored for query
160 ** sequences of type 'protein'.
161 **
162 ** N-terminus C-terminus
163 **
164 ** 2**n score 2**n score
165 ** - 0 - - 0
166 ** 0 1 alignment 0 1
167 ** - 0 non-matching region - 0
168 ** 2 4 shorter 1 2
169 ** 4 16 edge <= threshold 3 8
170 ** 6 64 perfect 5 32
171 ** 7 128 identity >= threshold 7 128
172 **
173 ******************************************************************************/
174
175 static const char *qcalignmentKQueryCoveragePropertiesProteinGenome[] =
176 {
177 "No Alignment",
178 "Alignment",
179 "C shorter",
180 "N shorter",
181 "C tolerance",
182 "N tolerance",
183 "C perfect",
184 "N perfect",
185 "Identity Threshold",
186 "Coverage Threshold",
187 "Sum",
188 (const char *) NULL
189 };
190 #endif /* AJFALSE */
191
192
193
194
195 #if AJFALSE
196 /* @conststatic qcalignmentKQueryCoveragePropertiesProteinProtein *************
197 **
198 ** Protein to Protein Query Coverage Scoring Schema
199 **
200 ** The query coverage score reflects individual alignment properties by
201 ** adding 2**n, where n increases with the quality of the alignment. The
202 ** following alignment properties are currently scored for query and
203 ** target sequences of type 'protein'.
204 **
205 ** N-terminus C-terminus
206 **
207 ** 2**n score 2**n score
208 ** - 0 - - 0
209 ** 0 1 alignment 0 1
210 ** - 0 non-matching region - 0
211 ** 2 4 shorter region 1 2
212 ** 4 16 longer region 3 8
213 ** 6 64 non-matching start/stop 5 32
214 ** 8 256 missing start/stop 7 128
215 ** 10 1024 added start/stop 9 512
216 ** 12 4096 perfect 11 2048
217 ** 13 8192 identity >= threshold 13 8192
218 **
219 ******************************************************************************/
220
221 static const char *qcalignmentKQueryCoveragePropertiesProteinProtein[] =
222 {
223 "No Alignment",
224 "Alignment",
225 "C shorter",
226 "N shorter",
227 "C longer",
228 "N longer",
229 "C non-matching stop",
230 "N non-matching start",
231 "C missing stop",
232 "N missing start",
233 "C added stop",
234 "N added start",
235 "C perfect",
236 "N perfect",
237 "Identity Threshold",
238 "Sum",
239 (const char *) NULL
240 };
241 #endif /* AJFALSE */
242
243
244
245
246 #if AJFALSE
247 /* @conststatic qcalignmentKQueryCoveragePropertiesQueryQuery *****************
248 **
249 ** Query to Query Comparison Scoring Schema
250 **
251 ** The query comparison score reflects individual alignment properties by
252 ** adding 2**n, where n increases with the quality of the alignment. The
253 ** following alignment properties are currently scored for query
254 ** sequences of type 'protein'.
255 **
256 ** 5'-terminus 3'-terminus
257 ** N-terminus C-terminus
258 **
259 ** 2**n score 2**n score
260 ** - 0 Alignment is missing - 0
261 ** 0 1 First alignment 0 1
262 ** 1 2 Second Alignment 1 2
263 ** 3 8 first query shorter 2 4
264 ** 5 32 first query longer 4 16
265 ** 7 128 equal 6 64
266 ** 9 512 perfect 8 256
267 ** 10 1024 sum 10 1024
268 **
269 ******************************************************************************/
270
271 static const char *qcalignmentKQueryCoveragePropertiesQueryQuery[] =
272 {
273 "No Alignment",
274 "Genome Alignment",
275 "Test Alignment",
276 "3' shorter",
277 "5' shorter",
278 "3' longer",
279 "5' longer",
280 "3' equal",
281 "5' equal",
282 "3' perfect",
283 "5' perfect",
284 "Sum",
285 (const char *) NULL
286 };
287 #endif /* AJFALSE */
288
289
290
291
292 /* @conststatic qcalignmentadaptorKTablenames *********************************
293 **
294 ** Array of Ensembl Quality Check Alignment Adaptor SQL table names
295 **
296 ******************************************************************************/
297
298 static const char *qcalignmentadaptorKTablenames[] =
299 {
300 "alignment",
301 (const char *) NULL
302 };
303
304
305
306
307 /* @conststatic qcalignmentadaptorKColumnnames ********************************
308 **
309 ** Array of Ensembl Quality Check Alignment Adaptor SQL column names
310 **
311 ******************************************************************************/
312
313 static const char *qcalignmentadaptorKColumnnames[] =
314 {
315 "alignment.alignment_id",
316 "alignment.analysis_id",
317 "alignment.query_db_id",
318 "alignment.query_id",
319 "alignment.query_start",
320 "alignment.query_end",
321 "alignment.query_strand",
322 "alignment.target_db_id",
323 "alignment.target_id",
324 "alignment.target_start",
325 "alignment.target_end",
326 "alignment.target_strand",
327 "alignment.splice_strand",
328 "alignment.score",
329 "alignment.identity",
330 "alignment.vulgar_line",
331 "alignment.coverage",
332 (const char *) NULL
333 };
334
335
336
337
338 /* ========================================================================= */
339 /* =========================== private variables =========================== */
340 /* ========================================================================= */
341
342
343
344
345 /* ========================================================================= */
346 /* =========================== private functions =========================== */
347 /* ========================================================================= */
348
349 static AjBool qcalignmentadaptorFetchAllbyStatement(
350 EnsPBaseadaptor ba,
351 const AjPStr statement,
352 EnsPAssemblymapper am,
353 EnsPSlice slice,
354 AjPList qcas);
355
356
357
358
359 /* ========================================================================= */
360 /* ======================= All functions by section ======================== */
361 /* ========================================================================= */
362
363
364
365
366 /* @filesection ensqcalignment ************************************************
367 **
368 ** @nam1rule ens Function belongs to the Ensembl library
369 **
370 ******************************************************************************/
371
372
373
374
375 /* @datasection [EnsPQcalignment] Ensembl Quality Check Alignment *************
376 **
377 ** @nam2rule Qcalignment Functions for manipulating
378 ** Ensembl Quality Check Alignment objects
379 **
380 ** @cc Bio::EnsEMBL::QC::Alignment
381 ** @cc CVS Revision:
382 ** @cc CVS Tag:
383 **
384 ******************************************************************************/
385
386
387
388
389 /* @section constructors ******************************************************
390 **
391 ** All constructors return a new Ensembl Quality Check Alignment by pointer.
392 ** It is the responsibility of the user to first destroy any previous
393 ** Quality Check Alignment. The target pointer does not need to be initialised
394 ** to NULL, but it is good programming practice to do so anyway.
395 **
396 ** @fdata [EnsPQcalignment]
397 **
398 ** @nam3rule New Constructor
399 ** @nam4rule Cpy Constructor with existing object
400 ** @nam4rule Ini Constructor with initial values
401 ** @nam4rule Ref Constructor by incrementing the reference counter
402 **
403 ** @argrule Cpy qca [const EnsPQcalignment] Ensembl Quality Check Alignment
404 ** @argrule Ini qcaa [EnsPQcalignmentadaptor]
405 ** Ensembl Quality Check Alignment Adaptor
406 ** @argrule Ini identifier [ajuint] SQL database-internal identifier
407 ** @argrule Ini analysis [EnsPAnalysis] Ensembl Analysis
408 ** @argrule Ini qsequence [EnsPQcsequence]
409 ** Query Ensembl Quality Check Sequence
410 ** @argrule Ini qstart [ajuint] Query start
411 ** @argrule Ini qend [ajuint] Query end
412 ** @argrule Ini qstrand [ajint] Query strand
413 ** @argrule Ini tsequence [EnsPQcsequence]
414 ** Target Ensembl Quality Check Sequence
415 ** @argrule Ini tstart [ajuint] Target start
416 ** @argrule Ini tend [ajuint] Target end
417 ** @argrule Ini tstrand [ajint] Target strand
418 ** @argrule Ini sstrand [ajint] Splice strand
419 ** @argrule Ini coverage [ajuint] Coverage score
420 ** @argrule Ini score [double] Score
421 ** @argrule Ini identity [float] Identity
422 ** @argrule Ini vulgar [AjPStr] Vulgar line
423 ** @argrule Ref qca [EnsPQcalignment] Ensembl Quality Check Alignment
424 **
425 ** @valrule * [EnsPQcalignment] Ensembl Quality Check Alignment or NULL
426 **
427 ** @fcategory new
428 ******************************************************************************/
429
430
431
432
433 /* @func ensQcalignmentNewCpy *************************************************
434 **
435 ** Object-based constructor function, which returns an independent object.
436 **
437 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
438 **
439 ** @return [EnsPQcalignment] Ensembl Quality Check Alignment or NULL
440 **
441 ** @release 6.4.0
442 ** @@
443 ******************************************************************************/
444
ensQcalignmentNewCpy(const EnsPQcalignment qca)445 EnsPQcalignment ensQcalignmentNewCpy(const EnsPQcalignment qca)
446 {
447 EnsPQcalignment pthis = NULL;
448
449 if (!qca)
450 return NULL;
451
452 AJNEW0(pthis);
453
454 pthis->Use = 1U;
455 pthis->Identifier = qca->Identifier;
456 pthis->Adaptor = qca->Adaptor;
457 pthis->Analysis = ensAnalysisNewRef(qca->Analysis);
458 pthis->QuerySequence = ensQcsequenceNewRef(qca->QuerySequence);
459 pthis->QueryStart = qca->QueryStart;
460 pthis->QueryEnd = qca->QueryEnd;
461 pthis->QueryStrand = qca->QueryStrand;
462 pthis->TargetSequence = ensQcsequenceNewRef(qca->TargetSequence);
463 pthis->TargetStart = qca->TargetStart;
464 pthis->TargetEnd = qca->TargetEnd;
465 pthis->TargetStrand = qca->TargetStrand;
466 pthis->Splicestrand = qca->Splicestrand;
467 pthis->Coverage = qca->Coverage;
468 pthis->Score = qca->Score;
469 pthis->Identity = qca->Identity;
470
471 if (qca->Vulgar)
472 pthis->Vulgar = ajStrNewRef(qca->Vulgar);
473
474 return pthis;
475 }
476
477
478
479
480 /* @func ensQcalignmentNewIni *************************************************
481 **
482 ** Constructor for an Ensembl Quality Check Alignment with initial values.
483 **
484 ** @cc Bio::EnsEMBL::Storable::new
485 ** @param [u] qcaa [EnsPQcalignmentadaptor]
486 ** Ensembl Quality Check Alignment Adaptor
487 ** @param [r] identifier [ajuint] SQL database-internal identifier
488 ** @cc Bio::EnsEMBL::QC::Alignment::new
489 ** @param [u] analysis [EnsPAnalysis] Ensembl Analysis
490 ** @param [u] qsequence [EnsPQcsequence] Query Ensembl Quality Check Sequence
491 ** @param [r] qstart [ajuint] Query start
492 ** @param [r] qend [ajuint] Query end
493 ** @param [r] qstrand [ajint] Query strand
494 ** @param [u] tsequence [EnsPQcsequence] Target Ensembl Quality Check Sequence
495 ** @param [r] tstart [ajuint] Target start
496 ** @param [r] tend [ajuint] Target end
497 ** @param [r] tstrand [ajint] Target strand
498 ** @param [r] sstrand [ajint] Splice strand
499 ** @param [r] coverage [ajuint] Coverage score
500 ** @param [r] score [double] Score
501 ** @param [r] identity [float] Identity
502 ** @param [u] vulgar [AjPStr] Vulgar line
503 **
504 ** @return [EnsPQcalignment] Ensembl Quality Check Alignment or NULL
505 **
506 ** @release 6.4.0
507 ** @@
508 ******************************************************************************/
509
ensQcalignmentNewIni(EnsPQcalignmentadaptor qcaa,ajuint identifier,EnsPAnalysis analysis,EnsPQcsequence qsequence,ajuint qstart,ajuint qend,ajint qstrand,EnsPQcsequence tsequence,ajuint tstart,ajuint tend,ajint tstrand,ajint sstrand,ajuint coverage,double score,float identity,AjPStr vulgar)510 EnsPQcalignment ensQcalignmentNewIni(EnsPQcalignmentadaptor qcaa,
511 ajuint identifier,
512 EnsPAnalysis analysis,
513 EnsPQcsequence qsequence,
514 ajuint qstart,
515 ajuint qend,
516 ajint qstrand,
517 EnsPQcsequence tsequence,
518 ajuint tstart,
519 ajuint tend,
520 ajint tstrand,
521 ajint sstrand,
522 ajuint coverage,
523 double score,
524 float identity,
525 AjPStr vulgar)
526 {
527 EnsPQcalignment qca = NULL;
528
529 if (!analysis)
530 return NULL;
531
532 if (!qsequence)
533 return NULL;
534
535 if (!tsequence)
536 return NULL;
537
538 AJNEW0(qca);
539
540 qca->Use = 1U;
541 qca->Identifier = identifier;
542 qca->Adaptor = qcaa;
543 qca->Analysis = ensAnalysisNewRef(analysis);
544 qca->QuerySequence = ensQcsequenceNewRef(qsequence);
545 qca->QueryStart = qstart;
546 qca->QueryEnd = qend;
547 qca->QueryStrand = qstrand;
548 qca->TargetSequence = ensQcsequenceNewRef(tsequence);
549 qca->TargetStart = tstart;
550 qca->TargetEnd = tend;
551 qca->TargetStrand = tstrand;
552 qca->Splicestrand = sstrand;
553 qca->Coverage = coverage;
554 qca->Score = score;
555 qca->Identity = identity;
556 qca->Vulgar = ajStrNewRef(vulgar);
557
558 return qca;
559 }
560
561
562
563
564 /* @func ensQcalignmentNewRef *************************************************
565 **
566 ** Ensembl Object referencing function, which returns a pointer to the
567 ** Ensembl Object passed in and increases its reference count.
568 **
569 ** @param [u] qca [EnsPQcalignment] Ensembl Alignment
570 **
571 ** @return [EnsPQcalignment] Ensembl Quality Check Alignment or NULL
572 **
573 ** @release 6.2.0
574 ** @@
575 ******************************************************************************/
576
ensQcalignmentNewRef(EnsPQcalignment qca)577 EnsPQcalignment ensQcalignmentNewRef(EnsPQcalignment qca)
578 {
579 if (!qca)
580 return NULL;
581
582 qca->Use++;
583
584 return qca;
585 }
586
587
588
589
590 /* @section destructors *******************************************************
591 **
592 ** Destruction destroys all internal data structures and frees the memory
593 ** allocated for an Ensembl Quality Check Alignment object.
594 **
595 ** @fdata [EnsPQcalignment]
596 **
597 ** @nam3rule Del Destroy (free) an Ensembl Quality Check Alignment
598 **
599 ** @argrule * Pqca [EnsPQcalignment*] Ensembl Quality Check Alignment address
600 **
601 ** @valrule * [void]
602 **
603 ** @fcategory delete
604 ******************************************************************************/
605
606
607
608
609 /* @func ensQcalignmentDel ****************************************************
610 **
611 ** Default destructor for an Ensembl Quality Check Alignment.
612 **
613 ** @param [d] Pqca [EnsPQcalignment*] Ensembl Quality Check Alignment address
614 **
615 ** @return [void]
616 **
617 ** @release 6.2.0
618 ** @@
619 ******************************************************************************/
620
ensQcalignmentDel(EnsPQcalignment * Pqca)621 void ensQcalignmentDel(EnsPQcalignment *Pqca)
622 {
623 EnsPQcalignment pthis = NULL;
624
625 if (!Pqca)
626 return;
627
628 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
629 if (ajDebugTest("ensQcalignmentDel"))
630 {
631 ajDebug("ensQcalignmentDel\n"
632 " *Pqca %p\n",
633 *Pqca);
634
635 ensQcalignmentTrace(*Pqca, 1);
636 }
637 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
638
639 if (!(pthis = *Pqca) || --pthis->Use)
640 {
641 *Pqca = NULL;
642
643 return;
644 }
645
646 ensAnalysisDel(&pthis->Analysis);
647
648 ensQcsequenceDel(&pthis->QuerySequence);
649 ensQcsequenceDel(&pthis->TargetSequence);
650
651 ajStrDel(&pthis->Vulgar);
652
653 ajMemFree((void **) Pqca);
654
655 return;
656 }
657
658
659
660
661 /* @section member retrieval **************************************************
662 **
663 ** Functions for returning members of an
664 ** Ensembl Quality Check Alignment object.
665 **
666 ** @fdata [EnsPQcalignment]
667 **
668 ** @nam3rule Get Return Quality Check Alignment attribute(s)
669 ** @nam4rule Adaptor Return the Ensembl Quality Check Alignment Adaptor
670 ** @nam4rule Analysis Return the Ensembl Analysis
671 ** @nam4rule Coverage Return the coverage
672 ** @nam4rule Identifier Return the SQL database-internal identifier
673 ** @nam4rule Identity Return the identity
674 ** @nam4rule Query Return query attribute(s)
675 ** @nam5rule End Return the query end
676 ** @nam5rule Sequence Return the query sequence
677 ** @nam5rule Start Return the query start
678 ** @nam5rule Strand Return the query strand
679 ** @nam4rule Score Return the score
680 ** @nam4rule Splicestrand Return the splice strand
681 ** @nam4rule Target Return target attribute(s)
682 ** @nam5rule End Return the query end
683 ** @nam5rule Sequence Return the query sequence
684 ** @nam5rule Start Return the query start
685 ** @nam5rule Strand Return the query strand
686 ** @nam4rule Vulgar Return the Vulgar line
687 **
688 ** @argrule * qca [const EnsPQcalignment] Ensembl Quality Check Alignment
689 **
690 ** @valrule Adaptor [EnsPQcalignmentadaptor]
691 ** Ensembl Quality Check Alignment Adaptor or NULL
692 ** @valrule Analysis [EnsPAnalysis] Ensembl Analysis or NULL
693 ** @valrule Coverage [ajuint] Coverage score or 0U
694 ** @valrule Identifier [ajuint] SQL database-internal identifier or 0U
695 ** @valrule Identity [float] Identity or 0.0F
696 ** @valrule QueryEnd [ajuint] Query end or 0U
697 ** @valrule QuerySequence [EnsPQcsequence]
698 ** Query Ensembl Quality Check Sequence or NULL
699 ** @valrule QueryStart [ajuint] Query start or 0U
700 ** @valrule QueryStrand [ajint] Query strand or 0
701 ** @valrule Score [double] Score or 0.0
702 ** @valrule Splicestrand [ajint] Splice strand or 0
703 ** @valrule TargetEnd [ajuint] Target end or 0U
704 ** @valrule TargetSequence [EnsPQcsequence]
705 ** Target Ensembl Quality Check Sequence or NULL
706 ** @valrule TargetStart [ajuint] Target start or 0U
707 ** @valrule TargetStrand [ajint] Target strand or 0
708 ** @valrule Vulgar [AjPStr] Vulgar line or NULL
709 **
710 ** @fcategory use
711 ******************************************************************************/
712
713
714
715
716 /* @func ensQcalignmentGetAdaptor *********************************************
717 **
718 ** Get the Ensembl Quality Check Alignment Adaptor member of an
719 ** Ensembl Quality Check Alignment.
720 **
721 ** @cc Bio::EnsEMBL::Storable::adaptor
722 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
723 **
724 ** @return [EnsPQcalignmentadaptor] Ensembl Quality Check Alignment Adaptor
725 ** or NULL
726 **
727 ** @release 6.2.0
728 ** @@
729 ******************************************************************************/
730
ensQcalignmentGetAdaptor(const EnsPQcalignment qca)731 EnsPQcalignmentadaptor ensQcalignmentGetAdaptor(const EnsPQcalignment qca)
732 {
733 return (qca) ? qca->Adaptor : NULL;
734 }
735
736
737
738
739 /* @func ensQcalignmentGetAnalysis ********************************************
740 **
741 ** Get the Ensembl Analysis member of an Ensembl Quality Check Alignment.
742 **
743 ** @cc Bio::EnsEMBL::QC::Alignment::analysis
744 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
745 **
746 ** @return [EnsPAnalysis] Ensembl Analysis or NULL
747 **
748 ** @release 6.2.0
749 ** @@
750 ******************************************************************************/
751
ensQcalignmentGetAnalysis(const EnsPQcalignment qca)752 EnsPAnalysis ensQcalignmentGetAnalysis(const EnsPQcalignment qca)
753 {
754 return (qca) ? qca->Analysis : NULL;
755 }
756
757
758
759
760 /* @func ensQcalignmentGetCoverage ********************************************
761 **
762 ** Get the coverage score member of an Ensembl Quality Check Alignment.
763 **
764 ** @cc Bio::EnsEMBL::QC::Alignment::coverage
765 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
766 **
767 ** @return [ajuint] Coverage score or 0U
768 **
769 ** @release 6.2.0
770 ** @@
771 ******************************************************************************/
772
ensQcalignmentGetCoverage(const EnsPQcalignment qca)773 ajuint ensQcalignmentGetCoverage(const EnsPQcalignment qca)
774 {
775 return (qca) ? qca->Coverage : 0U;
776 }
777
778
779
780
781 /* @func ensQcalignmentGetIdentifier ******************************************
782 **
783 ** Get the SQL database-internal identifier member of an
784 ** Ensembl Quality Check Alignment.
785 **
786 ** @cc Bio::EnsEMBL::Storable::dbID
787 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
788 **
789 ** @return [ajuint] SQL database-internal identifier or 0U
790 **
791 ** @release 6.2.0
792 ** @@
793 ******************************************************************************/
794
ensQcalignmentGetIdentifier(const EnsPQcalignment qca)795 ajuint ensQcalignmentGetIdentifier(const EnsPQcalignment qca)
796 {
797 return (qca) ? qca->Identifier : 0U;
798 }
799
800
801
802
803 /* @func ensQcalignmentGetIdentity ********************************************
804 **
805 ** Get the identity member of an Ensembl Quality Check Alignment.
806 **
807 ** @cc Bio::EnsEMBL::QC::Alignment::identity
808 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
809 **
810 ** @return [float] Identity or 0.0F
811 **
812 ** @release 6.2.0
813 ** @@
814 ******************************************************************************/
815
ensQcalignmentGetIdentity(const EnsPQcalignment qca)816 float ensQcalignmentGetIdentity(const EnsPQcalignment qca)
817 {
818 return (qca) ? qca->Identity : 0.0F;
819 }
820
821
822
823
824 /* @func ensQcalignmentGetQueryEnd ********************************************
825 **
826 ** Get the query end member of an Ensembl Quality Check Alignment.
827 **
828 ** @cc Bio::EnsEMBL::QC::Alignment::query_end
829 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
830 **
831 ** @return [ajuint] Query end or 0U
832 **
833 ** @release 6.2.0
834 ** @@
835 ******************************************************************************/
836
ensQcalignmentGetQueryEnd(const EnsPQcalignment qca)837 ajuint ensQcalignmentGetQueryEnd(const EnsPQcalignment qca)
838 {
839 return (qca) ? qca->QueryEnd : 0U;
840 }
841
842
843
844
845 /* @func ensQcalignmentGetQuerySequence ***************************************
846 **
847 ** Get the query Ensembl Quality Check Sequence member of an
848 ** Ensembl Quality Check Alignment.
849 **
850 ** @cc Bio::EnsEMBL::QC::Alignment::query_sequence
851 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
852 **
853 ** @return [EnsPQcsequence] Query Ensembl Quality Check Sequence or NULL
854 **
855 ** @release 6.2.0
856 ** @@
857 ******************************************************************************/
858
ensQcalignmentGetQuerySequence(const EnsPQcalignment qca)859 EnsPQcsequence ensQcalignmentGetQuerySequence(const EnsPQcalignment qca)
860 {
861 return (qca) ? qca->QuerySequence : NULL;
862 }
863
864
865
866
867 /* @func ensQcalignmentGetQueryStart ******************************************
868 **
869 ** Get the query start member of an Ensembl Quality Check Alignment.
870 **
871 ** @cc Bio::EnsEMBL::QC::Alignment::query_start
872 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
873 **
874 ** @return [ajuint] Query start or 0U
875 **
876 ** @release 6.2.0
877 ** @@
878 ******************************************************************************/
879
ensQcalignmentGetQueryStart(const EnsPQcalignment qca)880 ajuint ensQcalignmentGetQueryStart(const EnsPQcalignment qca)
881 {
882 return (qca) ? qca->QueryStart : 0U;
883 }
884
885
886
887
888 /* @func ensQcalignmentGetQueryStrand *****************************************
889 **
890 ** Get the query strand member of an Ensembl Quality Check Alignment.
891 **
892 ** @cc Bio::EnsEMBL::QC::Alignment::query_strand
893 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
894 **
895 ** @return [ajint] Query strand or 0
896 **
897 ** @release 6.2.0
898 ** @@
899 ******************************************************************************/
900
ensQcalignmentGetQueryStrand(const EnsPQcalignment qca)901 ajint ensQcalignmentGetQueryStrand(const EnsPQcalignment qca)
902 {
903 return (qca) ? qca->QueryStrand : 0;
904 }
905
906
907
908
909 /* @func ensQcalignmentGetScore ***********************************************
910 **
911 ** Get the score member of an Ensembl Quality Check Alignment.
912 **
913 ** @cc Bio::EnsEMBL::QC::Alignment::score
914 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
915 **
916 ** @return [double] Score or 0.0
917 **
918 ** @release 6.2.0
919 ** @@
920 ******************************************************************************/
921
ensQcalignmentGetScore(const EnsPQcalignment qca)922 double ensQcalignmentGetScore(const EnsPQcalignment qca)
923 {
924 return (qca) ? qca->Score : 0.0;
925 }
926
927
928
929
930 /* @func ensQcalignmentGetSplicestrand ****************************************
931 **
932 ** Get the splice strand member of an Ensembl Quality Check Alignment.
933 **
934 ** @cc Bio::EnsEMBL::QC::Alignment::splice_strand
935 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
936 **
937 ** @return [ajint] Splice strand or 0
938 **
939 ** @release 6.4.0
940 ** @@
941 ******************************************************************************/
942
ensQcalignmentGetSplicestrand(const EnsPQcalignment qca)943 ajint ensQcalignmentGetSplicestrand(const EnsPQcalignment qca)
944 {
945 return (qca) ? qca->Splicestrand : 0;
946 }
947
948
949
950
951 /* @func ensQcalignmentGetTargetEnd *******************************************
952 **
953 ** Get the target end member of an Ensembl Quality Check Alignment.
954 **
955 ** @cc Bio::EnsEMBL::QC::Alignment::target_end
956 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
957 **
958 ** @return [ajuint] Target end or 0U
959 **
960 ** @release 6.2.0
961 ** @@
962 ******************************************************************************/
963
ensQcalignmentGetTargetEnd(const EnsPQcalignment qca)964 ajuint ensQcalignmentGetTargetEnd(const EnsPQcalignment qca)
965 {
966 return (qca) ? qca->TargetEnd : 0U;
967 }
968
969
970
971
972 /* @func ensQcalignmentGetTargetSequence **************************************
973 **
974 ** Get the target Ensembl Quality Check Sequence member of an
975 ** Ensembl Quality Check Alignment.
976 **
977 ** @cc Bio::EnsEMBL::QC::Alignment::target_sequence
978 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
979 **
980 ** @return [EnsPQcsequence] Target Ensembl Quality Check Sequence or NULL
981 **
982 ** @release 6.2.0
983 ** @@
984 ******************************************************************************/
985
ensQcalignmentGetTargetSequence(const EnsPQcalignment qca)986 EnsPQcsequence ensQcalignmentGetTargetSequence(const EnsPQcalignment qca)
987 {
988 return (qca) ? qca->TargetSequence : NULL;
989 }
990
991
992
993
994 /* @func ensQcalignmentGetTargetStart *****************************************
995 **
996 ** Get the target start member of an Ensembl Quality Check Alignment.
997 **
998 ** @cc Bio::EnsEMBL::QC::Alignment::target_start
999 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
1000 **
1001 ** @return [ajuint] Target start or 0U
1002 **
1003 ** @release 6.2.0
1004 ** @@
1005 ******************************************************************************/
1006
ensQcalignmentGetTargetStart(const EnsPQcalignment qca)1007 ajuint ensQcalignmentGetTargetStart(const EnsPQcalignment qca)
1008 {
1009 return (qca) ? qca->TargetStart : 0U;
1010 }
1011
1012
1013
1014
1015 /* @func ensQcalignmentGetTargetStrand ****************************************
1016 **
1017 ** Get the target strand member of an Ensembl Quality Check Alignment.
1018 **
1019 ** @cc Bio::EnsEMBL::QC::Alignment::target_strand
1020 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
1021 **
1022 ** @return [ajint] Target strand or 0
1023 **
1024 ** @release 6.2.0
1025 ** @@
1026 ******************************************************************************/
1027
ensQcalignmentGetTargetStrand(const EnsPQcalignment qca)1028 ajint ensQcalignmentGetTargetStrand(const EnsPQcalignment qca)
1029 {
1030 return (qca) ? qca->TargetStrand : 0;
1031 }
1032
1033
1034
1035
1036 /* @func ensQcalignmentGetVulgar **********************************************
1037 **
1038 ** Get the Vulgar line member of an Ensembl Quality Check Alignment.
1039 **
1040 ** @cc Bio::EnsEMBL::QC::Alignment::vulgar_line
1041 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
1042 **
1043 ** @return [AjPStr] Vulgar line or NULL
1044 **
1045 ** @release 6.4.0
1046 ** @@
1047 ******************************************************************************/
1048
ensQcalignmentGetVulgar(const EnsPQcalignment qca)1049 AjPStr ensQcalignmentGetVulgar(const EnsPQcalignment qca)
1050 {
1051 return (qca) ? qca->Vulgar : NULL;
1052 }
1053
1054
1055
1056
1057 /* @section modifiers *********************************************************
1058 **
1059 ** Functions for assigning members of an
1060 ** Ensembl Quality Check Alignment object.
1061 **
1062 ** @fdata [EnsPQcalignment]
1063 **
1064 ** @nam3rule Set Set one member of an Ensembl Quality Check Alignment
1065 ** @nam4rule Adaptor Set the Ensembl Quality Check Alignment Adaptor
1066 ** @nam4rule Analysis Set the Ensembl Analysis
1067 ** @nam4rule Coverage Set the coverage score
1068 ** @nam4rule Identifier Set the SQL database-internal identifier
1069 ** @nam4rule Identity Set the identity
1070 ** @nam4rule Query Set query attribute(s)
1071 ** @nam5rule End Set the query end
1072 ** @nam5rule Sequence Set the query Ensembl Quality Check Sequence
1073 ** @nam5rule Start Set the query start
1074 ** @nam5rule Strand Set the query strand
1075 ** @nam4rule Score Set the score
1076 ** @nam4rule Splicestrand Set the splice strand
1077 ** @nam4rule Target Set target member(s)
1078 ** @nam5rule End Set the target end
1079 ** @nam5rule Sequence Set the target Ensembl Quality Check Sequence
1080 ** @nam5rule Start Set the target start
1081 ** @nam5rule Strand Set the target strand
1082 ** @nam4rule Vulgar Set the Vulgar line
1083 **
1084 ** @argrule * qca [EnsPQcalignment] Ensembl Quality Check Alignment
1085 ** @argrule Adaptor qcaa [EnsPQcalignmentadaptor]
1086 ** Ensembl Quality Check Alignment Adaptor
1087 ** @argrule Analysis analysis [EnsPAnalysis] Ensembl Analysis
1088 ** @argrule Coverage coverage [ajuint] Coverage score
1089 ** @argrule Identifier identifier [ajuint] SQL database-internal identifier
1090 ** @argrule Identity identity [float] Score
1091 ** @argrule QueryEnd qend [ajuint] Query end
1092 ** @argrule QuerySequence qsequence [EnsPQcsequence]
1093 ** Query Ensembl Quality Check Sequence
1094 ** @argrule QueryStart qstart [ajuint] Query start
1095 ** @argrule QueryStrand qstrand [ajint] Query strand
1096 ** @argrule Score score [double] Score
1097 ** @argrule Splicestrand sstrand [ajint] Splice strand
1098 ** @argrule TargetEnd tend [ajuint] Target end
1099 ** @argrule TargetSequence tsequence [EnsPQcsequence]
1100 ** Target Ensembl Quality Check Sequence
1101 ** @argrule TargetStart tstart [ajuint] Target start
1102 ** @argrule TargetStrand tstrand [ajint] Target strand
1103 ** @argrule Vulgar vulgar [AjPStr] Vulgar line
1104 **
1105 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
1106 **
1107 ** @fcategory modify
1108 ******************************************************************************/
1109
1110
1111
1112
1113 /* @func ensQcalignmentSetAdaptor *********************************************
1114 **
1115 ** Set the Ensembl Quality Check Alignment Adaptor member of an
1116 ** Ensembl Quality Check Alignment.
1117 **
1118 ** @cc Bio::EnsEMBL::Storable::adaptor
1119 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1120 ** @param [u] qcaa [EnsPQcalignmentadaptor]
1121 ** Ensembl Quality Check Alignment Adaptor
1122 **
1123 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1124 **
1125 ** @release 6.2.0
1126 ** @@
1127 ******************************************************************************/
1128
ensQcalignmentSetAdaptor(EnsPQcalignment qca,EnsPQcalignmentadaptor qcaa)1129 AjBool ensQcalignmentSetAdaptor(EnsPQcalignment qca,
1130 EnsPQcalignmentadaptor qcaa)
1131 {
1132 if (!qca)
1133 return ajFalse;
1134
1135 qca->Adaptor = qcaa;
1136
1137 return ajTrue;
1138 }
1139
1140
1141
1142
1143 /* @func ensQcalignmentSetAnalysis ********************************************
1144 **
1145 ** Set the Ensembl Analysis member of an Ensembl Quality Check Alignment.
1146 **
1147 ** @cc Bio::EnsEMBL::QC::Alignment::analysis
1148 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1149 ** @param [uN] analysis [EnsPAnalysis] Ensembl Analysis
1150 **
1151 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1152 **
1153 ** @release 6.2.0
1154 ** @@
1155 ******************************************************************************/
1156
ensQcalignmentSetAnalysis(EnsPQcalignment qca,EnsPAnalysis analysis)1157 AjBool ensQcalignmentSetAnalysis(EnsPQcalignment qca,
1158 EnsPAnalysis analysis)
1159 {
1160 if (!qca)
1161 return ajFalse;
1162
1163 ensAnalysisDel(&qca->Analysis);
1164
1165 qca->Analysis = ensAnalysisNewRef(analysis);
1166
1167 return ajTrue;
1168 }
1169
1170
1171
1172
1173 /* @func ensQcalignmentSetCoverage ********************************************
1174 **
1175 ** Set the coverage score member of an Ensembl Quality Check Alignment.
1176 **
1177 ** @cc Bio::EnsEMBL::QC::Alignment::coverage
1178 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1179 ** @param [r] coverage [ajuint] Coverage score
1180 **
1181 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1182 **
1183 ** @release 6.2.0
1184 ** @@
1185 ******************************************************************************/
1186
ensQcalignmentSetCoverage(EnsPQcalignment qca,ajuint coverage)1187 AjBool ensQcalignmentSetCoverage(EnsPQcalignment qca,
1188 ajuint coverage)
1189 {
1190 if (!qca)
1191 return ajFalse;
1192
1193 qca->Coverage = coverage;
1194
1195 return ajTrue;
1196 }
1197
1198
1199
1200
1201 /* @func ensQcalignmentSetIdentifier ******************************************
1202 **
1203 ** Set the SQL database-internal identifier member of an
1204 ** Ensembl Quality Check Alignment.
1205 **
1206 ** @cc Bio::EnsEMBL::Storable::dbID
1207 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1208 ** @param [r] identifier [ajuint] SQL database-internal identifier
1209 **
1210 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1211 **
1212 ** @release 6.2.0
1213 ** @@
1214 ******************************************************************************/
1215
ensQcalignmentSetIdentifier(EnsPQcalignment qca,ajuint identifier)1216 AjBool ensQcalignmentSetIdentifier(EnsPQcalignment qca,
1217 ajuint identifier)
1218 {
1219 if (!qca)
1220 return ajFalse;
1221
1222 qca->Identifier = identifier;
1223
1224 return ajTrue;
1225 }
1226
1227
1228
1229
1230 /* @func ensQcalignmentSetIdentity ********************************************
1231 **
1232 ** Set the identity member of an Ensembl Quality Check Alignment.
1233 **
1234 ** @cc Bio::EnsEMBL::QC::Alignment::identity
1235 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1236 ** @param [r] identity [float] Score
1237 **
1238 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1239 **
1240 ** @release 6.2.0
1241 ** @@
1242 ******************************************************************************/
1243
ensQcalignmentSetIdentity(EnsPQcalignment qca,float identity)1244 AjBool ensQcalignmentSetIdentity(EnsPQcalignment qca,
1245 float identity)
1246 {
1247 if (!qca)
1248 return ajFalse;
1249
1250 qca->Identity = identity;
1251
1252 return ajTrue;
1253 }
1254
1255
1256
1257
1258 /* @func ensQcalignmentSetQueryEnd ********************************************
1259 **
1260 ** Set the query end member of an Ensembl Quality Check Alignment.
1261 **
1262 ** @cc Bio::EnsEMBL::QC::Alignment::query_end
1263 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1264 ** @param [r] qend [ajuint] Query end
1265 **
1266 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1267 **
1268 ** @release 6.2.0
1269 ** @@
1270 ******************************************************************************/
1271
ensQcalignmentSetQueryEnd(EnsPQcalignment qca,ajuint qend)1272 AjBool ensQcalignmentSetQueryEnd(EnsPQcalignment qca,
1273 ajuint qend)
1274 {
1275 if (!qca)
1276 return ajFalse;
1277
1278 qca->QueryEnd = qend;
1279
1280 return ajTrue;
1281 }
1282
1283
1284
1285
1286 /* @func ensQcalignmentSetQuerySequence ***************************************
1287 **
1288 ** Set the query Ensembl Quality Check Sequence member of an
1289 ** Ensembl Quality Check Alignment.
1290 **
1291 ** @cc Bio::EnsEMBL::QC::Alignment::query_sequence
1292 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1293 ** @param [uN] qsequence [EnsPQcsequence] Ensembl Quality Check Sequence
1294 **
1295 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1296 **
1297 ** @release 6.2.0
1298 ** @@
1299 ******************************************************************************/
1300
ensQcalignmentSetQuerySequence(EnsPQcalignment qca,EnsPQcsequence qsequence)1301 AjBool ensQcalignmentSetQuerySequence(EnsPQcalignment qca,
1302 EnsPQcsequence qsequence)
1303 {
1304 if (!qca)
1305 return ajFalse;
1306
1307 ensQcsequenceDel(&qca->QuerySequence);
1308
1309 qca->QuerySequence = ensQcsequenceNewRef(qsequence);
1310
1311 return ajTrue;
1312 }
1313
1314
1315
1316
1317 /* @func ensQcalignmentSetQueryStart ******************************************
1318 **
1319 ** Set the query start member of an Ensembl Quality Check Alignment.
1320 **
1321 ** @cc Bio::EnsEMBL::QC::Alignment::query_start
1322 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1323 ** @param [r] qstart [ajuint] Query start
1324 **
1325 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1326 **
1327 ** @release 6.2.0
1328 ** @@
1329 ******************************************************************************/
1330
ensQcalignmentSetQueryStart(EnsPQcalignment qca,ajuint qstart)1331 AjBool ensQcalignmentSetQueryStart(EnsPQcalignment qca,
1332 ajuint qstart)
1333 {
1334 if (!qca)
1335 return ajFalse;
1336
1337 qca->QueryStart = qstart;
1338
1339 return ajTrue;
1340 }
1341
1342
1343
1344
1345 /* @func ensQcalignmentSetQueryStrand *****************************************
1346 **
1347 ** Set the query strand member of an Ensembl Quality Check Alignment.
1348 **
1349 ** @cc Bio::EnsEMBL::QC::Alignment::query_strand
1350 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1351 ** @param [r] qstrand [ajint] Query strand
1352 **
1353 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1354 **
1355 ** @release 6.2.0
1356 ** @@
1357 ******************************************************************************/
1358
ensQcalignmentSetQueryStrand(EnsPQcalignment qca,ajint qstrand)1359 AjBool ensQcalignmentSetQueryStrand(EnsPQcalignment qca,
1360 ajint qstrand)
1361 {
1362 if (!qca)
1363 return ajFalse;
1364
1365 qca->QueryStrand = qstrand;
1366
1367 return ajTrue;
1368 }
1369
1370
1371
1372
1373 /* @func ensQcalignmentSetScore ***********************************************
1374 **
1375 ** Set the score member of an Ensembl Quality Check Alignment.
1376 **
1377 ** @cc Bio::EnsEMBL::QC::Alignment::score
1378 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1379 ** @param [r] score [double] Score
1380 **
1381 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1382 **
1383 ** @release 6.2.0
1384 ** @@
1385 ******************************************************************************/
1386
ensQcalignmentSetScore(EnsPQcalignment qca,double score)1387 AjBool ensQcalignmentSetScore(EnsPQcalignment qca, double score)
1388 {
1389 if (!qca)
1390 return ajFalse;
1391
1392 qca->Score = score;
1393
1394 return ajTrue;
1395 }
1396
1397
1398
1399
1400 /* @func ensQcalignmentSetSplicestrand ****************************************
1401 **
1402 ** Set the splice strand member of an Ensembl Quality Check Alignment.
1403 **
1404 ** @cc Bio::EnsEMBL::QC::Alignment::splice_strand
1405 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1406 ** @param [r] sstrand [ajint] Splice strand
1407 **
1408 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1409 **
1410 ** @release 6.4.0
1411 ** @@
1412 ******************************************************************************/
1413
ensQcalignmentSetSplicestrand(EnsPQcalignment qca,ajint sstrand)1414 AjBool ensQcalignmentSetSplicestrand(EnsPQcalignment qca,
1415 ajint sstrand)
1416 {
1417 if (!qca)
1418 return ajFalse;
1419
1420 qca->Splicestrand = sstrand;
1421
1422 return ajTrue;
1423 }
1424
1425
1426
1427
1428 /* @func ensQcalignmentSetTargetEnd *******************************************
1429 **
1430 ** Set the target end member of an Ensembl Quality Check Alignment.
1431 **
1432 ** @cc Bio::EnsEMBL::QC::Alignment::target_end
1433 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1434 ** @param [r] tend [ajuint] Target end
1435 **
1436 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1437 **
1438 ** @release 6.2.0
1439 ** @@
1440 ******************************************************************************/
1441
ensQcalignmentSetTargetEnd(EnsPQcalignment qca,ajuint tend)1442 AjBool ensQcalignmentSetTargetEnd(EnsPQcalignment qca,
1443 ajuint tend)
1444 {
1445 if (!qca)
1446 return ajFalse;
1447
1448 qca->TargetEnd = tend;
1449
1450 return ajTrue;
1451 }
1452
1453
1454
1455
1456 /* @func ensQcalignmentSetTargetSequence **************************************
1457 **
1458 ** Set the target Ensembl Quality Check Sequence member of an
1459 ** Ensembl Quality Check Alignment.
1460 **
1461 ** @cc Bio::EnsEMBL::QC::Alignment::target_sequence
1462 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1463 ** @param [u] tsequence [EnsPQcsequence] Ensembl Quality Check Sequence
1464 **
1465 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1466 **
1467 ** @release 6.2.0
1468 ** @@
1469 ******************************************************************************/
1470
ensQcalignmentSetTargetSequence(EnsPQcalignment qca,EnsPQcsequence tsequence)1471 AjBool ensQcalignmentSetTargetSequence(EnsPQcalignment qca,
1472 EnsPQcsequence tsequence)
1473 {
1474 if (!qca)
1475 return ajFalse;
1476
1477 ensQcsequenceDel(&qca->TargetSequence);
1478
1479 qca->TargetSequence = ensQcsequenceNewRef(tsequence);
1480
1481 return ajTrue;
1482 }
1483
1484
1485
1486
1487 /* @func ensQcalignmentSetTargetStart *****************************************
1488 **
1489 ** Set the target start member of an Ensembl Quality Check Alignment.
1490 **
1491 ** @cc Bio::EnsEMBL::QC::Alignment::target_start
1492 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1493 ** @param [r] tstart [ajuint] Target start
1494 **
1495 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1496 **
1497 ** @release 6.2.0
1498 ** @@
1499 ******************************************************************************/
1500
ensQcalignmentSetTargetStart(EnsPQcalignment qca,ajuint tstart)1501 AjBool ensQcalignmentSetTargetStart(EnsPQcalignment qca,
1502 ajuint tstart)
1503 {
1504 if (!qca)
1505 return ajFalse;
1506
1507 qca->TargetStart = tstart;
1508
1509 return ajTrue;
1510 }
1511
1512
1513
1514
1515 /* @func ensQcalignmentSetTargetStrand ****************************************
1516 **
1517 ** Set the target strand member of an Ensembl Quality Check Alignment.
1518 **
1519 ** @cc Bio::EnsEMBL::QC::Alignment::target_strand
1520 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1521 ** @param [r] tstrand [ajint] Target strand
1522 **
1523 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1524 **
1525 ** @release 6.2.0
1526 ** @@
1527 ******************************************************************************/
1528
ensQcalignmentSetTargetStrand(EnsPQcalignment qca,ajint tstrand)1529 AjBool ensQcalignmentSetTargetStrand(EnsPQcalignment qca,
1530 ajint tstrand)
1531 {
1532 if (!qca)
1533 return ajFalse;
1534
1535 qca->TargetStrand = tstrand;
1536
1537 return ajTrue;
1538 }
1539
1540
1541
1542
1543 /* @func ensQcalignmentSetVulgar **********************************************
1544 **
1545 ** Set the Vulgar line member of an Ensembl Quality Check Alignment.
1546 **
1547 ** @cc Bio::EnsEMBL::QC::Alignment::vulgar_line
1548 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1549 ** @param [uN] vulgar [AjPStr] Vulgar line
1550 **
1551 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1552 **
1553 ** @release 6.4.0
1554 ** @@
1555 ******************************************************************************/
1556
ensQcalignmentSetVulgar(EnsPQcalignment qca,AjPStr vulgar)1557 AjBool ensQcalignmentSetVulgar(EnsPQcalignment qca,
1558 AjPStr vulgar)
1559 {
1560 if (!qca)
1561 return ajFalse;
1562
1563 ajStrDel(&qca->Vulgar);
1564
1565 qca->Vulgar = ajStrNewRef(vulgar);
1566
1567 return ajTrue;
1568 }
1569
1570
1571
1572
1573 /* @section debugging *********************************************************
1574 **
1575 ** Functions for reporting of an Ensembl Quality Check Alignment object.
1576 **
1577 ** @fdata [EnsPQcalignment]
1578 **
1579 ** @nam3rule Trace Report Ensembl Quality Check Alignment members to
1580 ** debug file
1581 **
1582 ** @argrule Trace qca [const EnsPQcalignment] Ensembl Quality Check Alignment
1583 ** @argrule Trace level [ajuint] Indentation level
1584 **
1585 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
1586 **
1587 ** @fcategory misc
1588 ******************************************************************************/
1589
1590
1591
1592
1593 /* @func ensQcalignmentTrace **************************************************
1594 **
1595 ** Trace an Ensembl Quality Check Alignment.
1596 **
1597 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
1598 ** @param [r] level [ajuint] Indentation level
1599 **
1600 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1601 **
1602 ** @release 6.2.0
1603 ** @@
1604 ******************************************************************************/
1605
ensQcalignmentTrace(const EnsPQcalignment qca,ajuint level)1606 AjBool ensQcalignmentTrace(const EnsPQcalignment qca, ajuint level)
1607 {
1608 AjPStr indent = NULL;
1609
1610 if (!qca)
1611 return ajFalse;
1612
1613 indent = ajStrNew();
1614
1615 ajStrAppendCountK(&indent, ' ', level * 2);
1616
1617 ajDebug("%SensQcalignmentTrace %p\n"
1618 "%S Use %u\n"
1619 "%S Identifier %u\n"
1620 "%S Adaptor %p\n"
1621 "%S Analysis %p\n"
1622 "%S QuerySequence %p\n"
1623 "%S QueryStart %u\n"
1624 "%S QueryEnd %u\n"
1625 "%S QueryStrand %d\n"
1626 "%S TargetSequence %p\n"
1627 "%S TargetStart %u\n"
1628 "%S TargetEnd %u\n"
1629 "%S TargetStrand %d\n"
1630 "%S Splicestrand %d\n"
1631 "%S Coverage %u\n"
1632 "%S Score %f\n"
1633 "%S Identity %f\n"
1634 "%S Vulgar '%S'\n",
1635 indent, qca,
1636 indent, qca->Use,
1637 indent, qca->Identifier,
1638 indent, qca->Adaptor,
1639 indent, qca->Analysis,
1640 indent, qca->QuerySequence,
1641 indent, qca->QueryStart,
1642 indent, qca->QueryEnd,
1643 indent, qca->QueryStrand,
1644 indent, qca->TargetSequence,
1645 indent, qca->TargetStart,
1646 indent, qca->TargetEnd,
1647 indent, qca->TargetStrand,
1648 indent, qca->Splicestrand,
1649 indent, qca->Coverage,
1650 indent, qca->Score,
1651 indent, qca->Identity,
1652 indent, qca->Vulgar);
1653
1654 ensAnalysisTrace(qca->Analysis, 1);
1655
1656 ensQcsequenceTrace(qca->QuerySequence, 1);
1657 ensQcsequenceTrace(qca->TargetSequence, 1);
1658
1659 ajStrDel(&indent);
1660
1661 return ajTrue;
1662 }
1663
1664
1665
1666
1667 /* @section calculate *********************************************************
1668 **
1669 ** Functions for calculating information from an
1670 ** Ensembl Quality Check Alignment object.
1671 **
1672 ** @fdata [EnsPQcalignment]
1673 **
1674 ** @nam3rule Calculate Calculate Ensembl Quality Check Alignment information
1675 ** @nam4rule Memsize Calculate the memory size in bytes
1676 ** @nam4rule Query Calculate query information
1677 ** @nam5rule Coordinates Calculate query coordinates
1678 ** @nam5rule Coverage Calculate the query coverage
1679 ** @nam6rule Dna Calculate the query coverage DNA information
1680 ** @nam7rule Dna Calculate the query coverage DNA to DNA
1681 ** @nam7rule Genome Calculate the query coverage DNA to Genome
1682 ** @nam6rule Protein Calculate the query coverage Protein information
1683 ** @nam7rule Protein Calculate the query coverage Protein to Protein
1684 ** @nam6rule Query Calculate the query coverage Query information
1685 ** @nam7rule Query Calculate the query coverage Query to Query
1686 ** @nam7rule Target Calculate the query coverage Query to Target
1687 ** @nam4rule Target Calculate target information
1688 ** @nam5rule Coordinates Calculate target coordinates
1689 **
1690 ** @argrule Memsize qca [const EnsPQcalignment] Ensembl Quality Check Alignment
1691 ** @argrule QueryCoordinates qca [const EnsPQcalignment]
1692 ** Ensembl Quality Check Alignment
1693 ** @argrule QueryCoordinates Pstart [ajint*] Start
1694 ** @argrule QueryCoordinates Pend [ajint*] End
1695 ** @argrule QueryCoordinates Pstrand [ajint*] Strand
1696 ** @argrule QueryCoordinates Plength [ajuint*] Length
1697 ** @argrule QueryCoverageDnaDna qca [EnsPQcalignment]
1698 ** Ensembl Quality Check Alignment
1699 ** @argrule QueryCoverageDnaDna identity [float] Identity threshold
1700 ** @argrule QueryCoverageDnaDna edge [ajuint] Edge threshold
1701 ** @argrule QueryCoverageDnaGenome qca [EnsPQcalignment]
1702 ** Ensembl Quality Check Alignment
1703 ** @argrule QueryCoverageDnaGenome identity [float] Identity threshold
1704 ** @argrule QueryCoverageDnaGenome edge [ajuint] Edge threshold
1705 ** @argrule QueryCoverageProteinGenome qca [EnsPQcalignment]
1706 ** Ensembl Quality Check Alignment
1707 ** @argrule QueryCoverageProteinGenome identity [float] Identity threshold
1708 ** @argrule QueryCoverageProteinGenome edge [ajuint] Edge threshold
1709 ** @argrule QueryCoverageProteinProtein qca [EnsPQcalignment]
1710 ** Ensembl Quality Check Alignment
1711 ** @argrule QueryCoverageProteinProtein identity [float] Identity threshold
1712 ** @argrule QueryCoverageQueryQuery qca1 [const EnsPQcalignment]
1713 ** First Ensembl Quality Check Alignment
1714 ** @argrule QueryCoverageQueryQuery qca2 [const EnsPQcalignment]
1715 ** Second Ensembl Quality Check Alignment
1716 ** @argrule QueryCoverageQueryQuery Pscore [ajuint*] Coverage score address
1717 ** @argrule QueryCoverageQueryTarget qca [EnsPQcalignment]
1718 ** Ensembl Quality Check Alignment
1719 ** @argrule QueryCoverageQueryTarget identity [float] Identity threshold
1720 ** @argrule QueryCoverageQueryTarget edge [ajuint] Edge threshold
1721 ** @argrule TargetCoordinates qca [const EnsPQcalignment]
1722 ** Ensembl Quality Check Alignment
1723 ** @argrule TargetCoordinates Pstart [ajint*] Start
1724 ** @argrule TargetCoordinates Pend [ajint*] End
1725 ** @argrule TargetCoordinates Pstrand [ajint*] Strand
1726 ** @argrule TargetCoordinates Plength [ajuint*] Length
1727 **
1728 ** @valrule Memsize [size_t] Memory size in bytes or 0
1729 ** @valrule QueryCoordinates [AjBool] ajTrue upon success, ajFalse otherwise
1730 ** @valrule QueryCoverage [AjBool] ajTrue upon success, ajFalse otherwise
1731 ** @valrule TargetCoordinates [AjBool] ajTrue upon success, ajFalse otherwise
1732 **
1733 ** @fcategory misc
1734 ******************************************************************************/
1735
1736
1737
1738
1739 /* @func ensQcalignmentCalculateMemsize ***************************************
1740 **
1741 ** Calculate the memory size in bytes of an Ensembl Quality Check Alignment.
1742 **
1743 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
1744 **
1745 ** @return [size_t] Memory size in bytes or 0
1746 **
1747 ** @release 6.4.0
1748 ** @@
1749 ******************************************************************************/
1750
ensQcalignmentCalculateMemsize(const EnsPQcalignment qca)1751 size_t ensQcalignmentCalculateMemsize(const EnsPQcalignment qca)
1752 {
1753 size_t size = 0;
1754
1755 if (!qca)
1756 return 0;
1757
1758 size += sizeof (EnsOQcalignment);
1759
1760 size += ensAnalysisCalculateMemsize(qca->Analysis);
1761
1762 size += ensQcsequenceCalculateMemsize(qca->QuerySequence);
1763 size += ensQcsequenceCalculateMemsize(qca->TargetSequence);
1764
1765 return size;
1766 }
1767
1768
1769
1770
1771 /* @func ensQcalignmentCalculateQueryCoordinates ******************************
1772 **
1773 ** Calculate query coordinates of an Ensembl Quality Check Alignment.
1774 **
1775 ** @cc Bio::EnsEMBL::QC::Alignment::query_coordinates
1776 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
1777 ** @param [wP] Pstart [ajint*] Start
1778 ** @param [wP] Pend [ajint*] End
1779 ** @param [wP] Pstrand [ajint*] Strand
1780 ** @param [wP] Plength [ajuint*] Length
1781 **
1782 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1783 **
1784 ** @release 6.4.0
1785 ** @@
1786 ******************************************************************************/
1787
ensQcalignmentCalculateQueryCoordinates(const EnsPQcalignment qca,ajint * Pstart,ajint * Pend,ajint * Pstrand,ajuint * Plength)1788 AjBool ensQcalignmentCalculateQueryCoordinates(
1789 const EnsPQcalignment qca,
1790 ajint *Pstart,
1791 ajint *Pend,
1792 ajint *Pstrand,
1793 ajuint *Plength)
1794 {
1795 if (!qca)
1796 return ajFalse;
1797
1798 if (!Pstart)
1799 return ajFalse;
1800
1801 if (!Pend)
1802 return ajFalse;
1803
1804 if (!Pstrand)
1805 return ajFalse;
1806
1807 if (!Plength)
1808 return ajFalse;
1809
1810 if (qca->QueryStrand >= 0)
1811 {
1812 *Pstart = qca->QueryStart;
1813 *Pend = qca->QueryEnd;
1814 }
1815 else
1816 {
1817 *Pstart = qca->QueryEnd;
1818 *Pend = qca->QueryStart;
1819 }
1820
1821 *Pstrand = qca->QueryStrand;
1822
1823 /* In Exonerate coordinates the length is just end - start. */
1824
1825 *Plength = *Pend - *Pstart;
1826
1827 return ajTrue;
1828 }
1829
1830
1831
1832
1833 /* @func ensQcalignmentCalculateQueryCoverageDnaDna ***************************
1834 **
1835 ** Calculates the alignment coverage score for a query of type 'dna'
1836 ** against a target of type 'dna' and sets the score in the coverage
1837 ** member of an Ensembl Quality Check Alignment.
1838 **
1839 ** @cc Bio::EnsEMBL::QC::Alignment::d2d_query_coverage
1840 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
1841 ** @param [r] identity [float] Identity threshold
1842 ** @param [r] edge [ajuint] Edge threshold to classify cases where only few
1843 ** residues at the edge are different.
1844 **
1845 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1846 **
1847 ** @release 6.4.0
1848 ** @@
1849 **
1850 ** DNA to DNA Query Coverage Criteria
1851 **
1852 ** 5'-Terminus Criteria and Scores 2**n score
1853 **
1854 ** QS==0 & TS==0 ==> perfect 12 4096
1855 ** QS==0 & TS<=E ==> longer edge 10 1024
1856 ** QS==0 & TS>E ==> longer region 4 16
1857 ** QS<=E & TS==0 ==> shorter edge 8 256
1858 ** QS<=E & TS<=E ==> non-matching edge 6 64
1859 ** QS<=E & TS>E ==> non-matching region - 0
1860 ** QS>E & TS==0 ==> shorter region 2 4
1861 ** QS>E & TS>0 ==> non-matching region - 0
1862 **
1863 ** 3'-Terminus Criteria and Scores 2**n score
1864 **
1865 ** QE>=QL & TE>=TL ==> perfect 11 2048
1866 ** QE>=QL & TE>=TL-E ==> longer edge 9 512
1867 ** QE>=QL & TE<TL-E ==> longer region 3 8
1868 ** QE>=QL-E & TE>=TL ==> shorter edge 7 128
1869 ** QE>=QL-E & TE>=TL-E ==> non-matching edge 5 32
1870 ** QE>=QL-E & TE<TL-E ==> non-matching region - 0
1871 ** QE<QL-E & TE>=TL ==> shorter region 1 2
1872 ** QE<QL-E & TE<TL ==> non-matching - 0
1873 **
1874 ******************************************************************************/
1875
ensQcalignmentCalculateQueryCoverageDnaDna(EnsPQcalignment qca,float identity,ajuint edge)1876 AjBool ensQcalignmentCalculateQueryCoverageDnaDna(
1877 EnsPQcalignment qca,
1878 float identity,
1879 ajuint edge)
1880 {
1881 ajuint qlength = 0U;
1882 ajuint tlength = 0U;
1883
1884 ajint qstart = 0;
1885 ajint qend = 0;
1886 ajint qstrand = 0;
1887 ajint tstart = 0;
1888 ajint tend = 0;
1889 ajint tstrand = 0;
1890
1891 if (!qca)
1892 return ajFalse;
1893
1894 /* An Alignment object without a target automatically has coverage 0. */
1895
1896 qca->Coverage = 0U;
1897
1898 if (!qca->TargetSequence)
1899 return ajTrue;
1900
1901 /* Assign alignment coordinates strand-dependent. */
1902
1903 ensQcalignmentCalculateQueryCoordinates(qca,
1904 &qstart,
1905 &qend,
1906 &qstrand,
1907 &qlength);
1908
1909 ensQcalignmentCalculateTargetCoordinates(qca,
1910 &tstart,
1911 &tend,
1912 &tstrand,
1913 &tlength);
1914
1915 qlength = ensQcsequenceGetLength(qca->QuerySequence);
1916 tlength = ensQcsequenceGetLength(qca->TargetSequence);
1917
1918 /* Correct sequence lengths for PolyA+ tails. */
1919
1920 qlength -= ensQcsequenceGetPolya(qca->QuerySequence);
1921 tlength -= ensQcsequenceGetPolya(qca->TargetSequence);
1922
1923 /* Alignment (1*2**0=1) */
1924 qca->Coverage += 1U;
1925
1926 /* Test for completeness of the 5'-terminus. */
1927
1928 if (qstart == 0)
1929 {
1930 /* Perfect 5'-terminus (1*2**12=4096) */
1931 if (tstart == 0)
1932 qca->Coverage += 4096U;
1933 /* Longer 5'-edge (1*2**10=1024) */
1934 else if (tstart <= (ajint) edge)
1935 qca->Coverage += 1024U;
1936 /* Longer 5'-region (1*2**4=16) */
1937 else if (tstart > (ajint) edge)
1938 qca->Coverage += 16U;
1939 else
1940 ajWarn("Error in 5'-terminus query coverage scoring schema. "
1941 "ID: %u QS: %d TS: %d", qca->Identifier, qstart, tstart);
1942 }
1943 else if (qstart <= (ajint) edge)
1944 {
1945 /* Shorter 5'-edge (1*2**8=256) */
1946 if (tstart == 0)
1947 qca->Coverage += 256U;
1948 /* Non-matching 5'-edge (1*2**6=64) */
1949 else if (tstart <= (ajint) edge)
1950 qca->Coverage += 64U;
1951 /* Non-matching 5'-region (0*2**0=0) */
1952 else if (tstart > (ajint) edge)
1953 qca->Coverage += 0U;
1954 else
1955 ajWarn("Error in 5'-terminus query coverage scoring schema. "
1956 "ID: %u QS: %d TS: %d", qca->Identifier, qstart, tstart);
1957 }
1958 else if (qstart > (ajint) edge)
1959 {
1960 /* Shorter 5'-region (1*2**2=4) */
1961 if (tstart == 0)
1962 qca->Coverage += 4U;
1963 /* Non-matching 5'-region (0*2**0=0) */
1964 else if (tstart > 0)
1965 qca->Coverage += 0U;
1966 else
1967 ajWarn("Error in 5'-terminus query coverage scoring schema. "
1968 "ID: %u QS: %d TS: %d", qca->Identifier, qstart, tstart);
1969 }
1970 else
1971 ajWarn("Error in 5'-terminus query coverage scoring schema. "
1972 "ID: %u QS: %d TS: %d", qca->Identifier, qstart, tstart);
1973
1974 /*
1975 ** Test for completeness of the 3'-terminus. As the PolyA tail
1976 ** detection algorithm could truncate As from the end of an mRNA,
1977 ** which were still represented by the genome, a perfect query end
1978 ** could be longer than the artificially truncated query length.
1979 **
1980 ** The same is true for the target length so that for each query case
1981 ** another condition testing for a target end exceeding the
1982 ** target length is required. Currently, scores as in the case of
1983 ** perfect overlaps are set.
1984 */
1985
1986 if (qend >= (ajint) qlength)
1987 {
1988 /*
1989 ** Perfect 3'-terminus, including over-estimated Poly A tails.
1990 ** (1*2**11=2048)
1991 */
1992 if (tend >= (ajint) tlength)
1993 qca->Coverage += 2048U;
1994 /* Longer 3'-edge (1*2**9=512) */
1995 else if (tend >= (ajint) (tlength - edge))
1996 qca->Coverage += 512U;
1997 /* Longer 3'-region (1*2**3=8) */
1998 else if (tend < (ajint) (tlength - edge))
1999 qca->Coverage += 8U;
2000 else
2001 ajWarn("Error in 3'-terminus query coverage scoring schema. "
2002 "ID: %u QE: %d QL: %u TE: %d TL: %u",
2003 qca->Identifier, qend, qlength, tend, tlength);
2004 }
2005 else if (qend >= (ajint) (qlength - edge))
2006 {
2007 /*
2008 ** Added 3'-edge, including over-estimated Poly A tails.
2009 ** (1*2**7=128)
2010 */
2011 if (tend >= (ajint) tlength)
2012 qca->Coverage += 128U;
2013 /* Non-matching 3'-edge (1*2**5=32) */
2014 else if (tend >= (ajint) (tlength - edge))
2015 qca->Coverage += 32U;
2016 /* Non-matching 3-'terminus (0*2**2=0) */
2017 else if (tend < (ajint) (tlength - edge))
2018 qca->Coverage += 0U;
2019 else
2020 ajWarn("Error in 3'-terminus query coverage scoring schema. "
2021 "ID: %u QE: %d QL: %u TE: %d TL: %u",
2022 qca->Identifier, qend, qlength, tend, tlength);
2023 }
2024 else if (qend < (ajint) (qlength - edge))
2025 {
2026 /* Shorter 3'-terminus (1*2**1=2) */
2027 if (tend >= (ajint) tlength)
2028 qca->Coverage += 2U;
2029 /* Non-matching 3'-terminus (0*2**0=0) */
2030 else if (tend < (ajint) tlength)
2031 qca->Coverage += 0U;
2032 else
2033 ajWarn("Error in 3'-terminus query coverage scoring schema. "
2034 "ID: %u QE: %d QL: %u TE: %d TL: %u",
2035 qca->Identifier, qend, qlength, tend, tlength);
2036 }
2037 else
2038 ajWarn("Error in 3'-terminus query coverage scoring schema. "
2039 "ID: %u QE: %d QL: %u TE: %d TL: %u",
2040 qca->Identifier, qend, qlength, tend, tlength);
2041
2042 /*
2043 ** Test for sequence identity over the identity threshold value
2044 ** only for perfect 5' and 3'-termini.
2045 ** (1*2**12 + 1*2**11 = 4096 + 2048 = 6144)
2046 ** Identity threshold value (1*2**13=8192).
2047 */
2048
2049 if ((qca->Coverage & 6144U) && (qca->Identity >= identity))
2050 qca->Coverage += 8192U;
2051
2052 return ajTrue;
2053 }
2054
2055
2056
2057
2058 /* @func ensQcalignmentCalculateQueryCoverageDnaGenome ************************
2059 **
2060 ** Calculates the alignment coverage score for a query of type 'dna'
2061 ** against a target of class 'genome' and sets the score in the coverage
2062 ** member of an Ensembl Quality Check Alignment.
2063 **
2064 ** @cc Bio::EnsEMBL::QC::Alignment::d2g_query_coverage
2065 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
2066 ** @param [r] identity [float] Identity threshold
2067 ** @param [r] edge [ajuint] Edge threshold to classify cases where only few
2068 ** residues at the edge fall into a separate exon.
2069 ** This is generally difficult to predict for
2070 ** alignment programs.
2071 **
2072 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2073 **
2074 ** @release 6.4.0
2075 ** @@
2076 **
2077 ** cDNA to Genome Query Coverage Criteria
2078 **
2079 ** 5'-Terminus Criteria and Scores 2**n score
2080 **
2081 ** QS=0 ==> perfect query 6 64
2082 ** QS<=TE ==> threshold edge 4 16
2083 ** QS>TE ==> shorter query 2 4
2084 **
2085 ** 3'-Terminus Criteria and Scores 2**n score
2086 **
2087 ** QE=QL ==> perfect target 5 32
2088 ** QE=>QL-TE ==> threshold edge 3 8
2089 ** QE<QL ==> shorter query 1 2
2090 **
2091 ******************************************************************************/
2092
ensQcalignmentCalculateQueryCoverageDnaGenome(EnsPQcalignment qca,float identity,ajuint edge)2093 AjBool ensQcalignmentCalculateQueryCoverageDnaGenome(
2094 EnsPQcalignment qca,
2095 float identity,
2096 ajuint edge)
2097 {
2098 ajuint qlength = 0U;
2099
2100 ajint qstart = 0;
2101 ajint qend = 0;
2102 ajint qstrand = 0;
2103
2104 if (!qca)
2105 return ajFalse;
2106
2107 /* An Alignment object without a target automatically has coverage 0. */
2108
2109 qca->Coverage = 0U;
2110
2111 if (!qca->TargetSequence)
2112 return ajTrue;
2113
2114 /* Assign alignment coordinates strand-dependent. */
2115
2116 ensQcalignmentCalculateQueryCoordinates(qca,
2117 &qstart,
2118 &qend,
2119 &qstrand,
2120 &qlength);
2121
2122 qlength = ensQcsequenceGetLength(qca->QuerySequence);
2123
2124 qlength -= ensQcsequenceGetPolya(qca->QuerySequence);
2125
2126 /* Alignment (1*2**0=1) */
2127 qca->Coverage += 1U;
2128
2129 /* Test for completeness of the 5' terminus. */
2130
2131 /* Perfect 5' terminus (1*2**6=64) */
2132 if (qstart == 0)
2133 qca->Coverage += 64U;
2134 /* Edge threshold (1*2**4=16) */
2135 else if (qstart <= (ajint) edge)
2136 qca->Coverage += 16U;
2137 /* Shorter 5' terminus (1*2**2=4) */
2138 else if (qstart > (ajint) edge)
2139 qca->Coverage += 4U;
2140 else
2141 ajWarn("Error in 5'-terminus query coverage scoring schema. "
2142 "ID: %u QS: %d", qca->Identifier, qstart);
2143
2144 /*
2145 ** Test for completeness of the 3' terminus. If part of a PolyA tail
2146 ** aligns to the genome sequence it may appear longer so that the end
2147 ** of the alignment actually extends the clipped mRNA sequence.
2148 */
2149
2150 /* Perfect 3' terminus (1*2**5=32) */
2151 if (qend >= (ajint) qlength)
2152 qca->Coverage += 32U;
2153 /* Edge threshold (1*2**3=8) */
2154 else if (qend >= (ajint) (qlength - edge))
2155 qca->Coverage += 8U;
2156 /* 3' terminus shorter (1*2**1=2) */
2157 else if (qend < (ajint) (qlength - edge))
2158 qca->Coverage += 2U;
2159 else
2160 ajWarn("Error in 3'-terminus coverage scoring schema. "
2161 "ID: %u QE: %d QL: %u",
2162 qca->Identifier, qend, qlength);
2163
2164 /*
2165 ** Test for sequence identity over the 'threshold_identity' value
2166 ** only for perfect 5' and 3'-termini.
2167 ** (1*2**6 + 1*2**5 = 32 + 64 = 96)
2168 ** Identity threshold value (1*2**7=128).
2169 */
2170
2171 if ((qca->Coverage & 96U) && (qca->Identity >= identity))
2172 qca->Coverage += 128U;
2173
2174 return ajTrue;
2175 }
2176
2177
2178
2179
2180 /* @func ensQcalignmentCalculateQueryCoverageProteinGenome ********************
2181 **
2182 ** Calculates the alignment coverage score for a query of type 'protein'
2183 ** against a target of class 'genome' and sets the score in the coverage
2184 ** member of an Ensembl Quality Check Alignment.
2185 **
2186 ** @cc Bio::EnsEMBL::QC::Alignment::p2g_query_coverage
2187 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
2188 ** @param [r] identity [float] Identity threshold
2189 ** @param [r] edge [ajuint] Edge threshold
2190 **
2191 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2192 **
2193 ** @release 6.4.0
2194 ** @@
2195 **
2196 ** Protein to Genome Query Coverage Criteria
2197 **
2198 ** N-Terminus Criteria and Scores 2**n score
2199 **
2200 ** QS=0 ==> perfect 6 64
2201 ** QS<=TE ==> edge threshold 4 16
2202 ** QS>TE ==> shorter 2 4
2203 **
2204 ** C-Terminus Criteria and Scores 2**n score
2205 **
2206 ** QE=QL ==> perfect 5 32
2207 ** QE=>QL-TE ==> edge threshold 3 8
2208 ** QE<QL ==> shorter 1 2
2209 **
2210 ******************************************************************************/
2211
ensQcalignmentCalculateQueryCoverageProteinGenome(EnsPQcalignment qca,float identity,ajuint edge)2212 AjBool ensQcalignmentCalculateQueryCoverageProteinGenome(
2213 EnsPQcalignment qca,
2214 float identity,
2215 ajuint edge)
2216 {
2217 ajuint qlength = 0U;
2218
2219 ajint qstart = 0;
2220 ajint qend = 0;
2221 ajint qstrand = 0;
2222
2223 if (!qca)
2224 return ajFalse;
2225
2226 /* An Alignment object without a target automatically has coverage 0. */
2227
2228 qca->Coverage = 0U;
2229
2230 if (!qca->TargetSequence)
2231 return ajTrue;
2232
2233 /* Assign alignment coordinates strand-dependent. */
2234
2235 ensQcalignmentCalculateQueryCoordinates(qca,
2236 &qstart,
2237 &qend,
2238 &qstrand,
2239 &qlength);
2240
2241 qlength = ensQcsequenceGetLength(qca->QuerySequence);
2242
2243 /* Alignment (1*2**0=1) */
2244 qca->Coverage += 1U;
2245
2246 /* Test for completeness of the N-terminus. */
2247
2248 /* Perfect N-terminus (1*2**6=64) */
2249 if (qstart == 0)
2250 qca->Coverage += 64U;
2251 /* Edge threshold (1*2**4=16) */
2252 else if (qstart <= (ajint) edge)
2253 qca->Coverage += 16U;
2254 /* Shorter N-terminus (1*2**2=4) */
2255 else if (qstart > (ajint) edge)
2256 qca->Coverage += 4U;
2257 else
2258 ajWarn("Error in N-terminus query coverage scoring schema. "
2259 "ID: %d QS: %d", qca->Identifier, qstart);
2260
2261 /* Test for completeness of the C-terminus. */
2262
2263 /* Perfect C-terminus (1*2**5=32) */
2264 if (qend == (ajint) qlength)
2265 qca->Coverage += 32U;
2266 /* Edge threshold (1*2**3=8) */
2267 else if (qend >= (ajint) (qlength - edge))
2268 qca->Coverage += 8U;
2269 /* Shorter C-terminus (1*2**1=2) */
2270 else if (qend < (ajint) (qlength - edge))
2271 qca->Coverage += 2U;
2272 else
2273 ajWarn("Error in C-terminus coverage scoring schema. "
2274 "ID: %u QE: %d QL: %u", qca->Identifier, qend, qlength);
2275
2276 /*
2277 ** Test for sequence identity over the identity threshold value
2278 ** only for perfect N and C-termini.
2279 ** (1*2**6 + 1*2**5 = 64 + 32 = 96)
2280 ** Identity threshold value (1*2**7=128)
2281 */
2282
2283 if ((qca->Coverage & 96U) && (qca->Identity >= identity))
2284 qca->Coverage += 128U;
2285
2286 return ajTrue;
2287 }
2288
2289
2290
2291
2292 /* @func ensQcalignmentCalculateQueryCoverageProteinProtein *******************
2293 **
2294 ** Calculates the alignment coverage score for a query of type 'protein'
2295 ** against a target of type 'protein' and sets the score in the coverage
2296 ** member of an Ensembl Quality Check Alignment.
2297 **
2298 ** @cc Bio::EnsEMBL::QC::Alignment::p2p_query_coverage
2299 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
2300 ** @param [r] identity [float] Identity threshold
2301 **
2302 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2303 **
2304 ** @release 6.4.0
2305 ** @@
2306 **
2307 ** Protein to Protein Query Coverage Criteria
2308 **
2309 ** N-Terminus Criteria and Scores 2**n score
2310 **
2311 ** QS==0 & TS==0 ==> perfect 12 4096
2312 ** QS==0 & TS==1 ==> added start 10 1024
2313 ** QS==0 & TS> 1 ==> longer region 4 16
2314 ** QS==1 & TS==0 ==> missing start 8 256
2315 ** QS==1 & TS==1 ==> non-matching start 6 64
2316 ** QS==1 & TS> 1 ==> non-matching region - 0
2317 ** QS> 1 & TS==0 ==> shorter region 2 4
2318 ** QS> 1 & TS> 0 ==> non-matching region - 0
2319 **
2320 ** C-Terminus Criteria and Scores 2**n score
2321 **
2322 ** QE=QL & TE=TL ==> perfect 11 2048
2323 ** QE=QL & TE=TL-1 ==> added stop 9 512
2324 ** QE=QL & TE<TL-1 ==> longer region 3 8
2325 ** QE=QL-1 & TE=TL ==> missing stop 7 128
2326 ** QE=QL-1 & TE=TL-1 ==> non-matching stop 5 32
2327 ** QE=QL-1 & TE<TL-1 ==> non-matching region - 0
2328 ** QE<QL-1 & TE=TL ==> shorter region 1 2
2329 ** QE<QL-1 & TE<TL ==> non-matching region - 0
2330 **
2331 ******************************************************************************/
2332
ensQcalignmentCalculateQueryCoverageProteinProtein(EnsPQcalignment qca,float identity)2333 AjBool ensQcalignmentCalculateQueryCoverageProteinProtein(
2334 EnsPQcalignment qca,
2335 float identity)
2336 {
2337 ajuint qlength = 0U;
2338 ajuint tlength = 0U;
2339
2340 ajint qstart = 0;
2341 ajint qend = 0;
2342 ajint qstrand = 0;
2343 ajint tstart = 0;
2344 ajint tend = 0;
2345 ajint tstrand = 0;
2346
2347 if (!qca)
2348 return ajFalse;
2349
2350 /* An Alignment object without a target automatically has coverage 0. */
2351
2352 qca->Coverage = 0U;
2353
2354 if (!qca->TargetSequence)
2355 return ajTrue;
2356
2357 /* Alignment (1*2**0=1) */
2358 qca->Coverage += 1U;
2359
2360 /* Assign alignment coordinates strand-dependent. */
2361
2362 ensQcalignmentCalculateQueryCoordinates(qca,
2363 &qstart,
2364 &qend,
2365 &qstrand,
2366 &qlength);
2367
2368 ensQcalignmentCalculateTargetCoordinates(qca,
2369 &tstart,
2370 &tend,
2371 &tstrand,
2372 &tlength);
2373
2374 qlength = ensQcsequenceGetLength(qca->QuerySequence);
2375 tlength = ensQcsequenceGetLength(qca->TargetSequence);
2376
2377 /* Test for completeness of the N-terminus. */
2378
2379 if (qstart == 0)
2380 {
2381 /* Perfect N-terminus (1*2**12=4096) */
2382 if (tstart == 0)
2383 qca->Coverage += 4096U;
2384 /* Added start codon (1*2**10=1024) */
2385 else if (tstart == 1)
2386 qca->Coverage += 1024U;
2387 /* Longer N-terminus (1*2**4=16) */
2388 else if (tstart > 1)
2389 qca->Coverage += 16U;
2390 else
2391 ajWarn("Error in N-terminus query coverage scoring schema. "
2392 "ID: %u QS: %d TS: %d", qca->Identifier, qstart, tstart);
2393 }
2394 else if (qstart == 1)
2395 {
2396 /* Missing start codon (1*2**8=256) */
2397 if (tstart == 0)
2398 qca->Coverage += 256U;
2399 /* Non-matching start codon (1*2**6=64) */
2400 else if (tstart == 1)
2401 qca->Coverage += 64U;
2402 /* Non-matching N-terminus (0*2**1=0) */
2403 else if (tstart > 1)
2404 qca->Coverage += 0U;
2405 else
2406 ajWarn("Error in N-terminus query coverage scoring schema. "
2407 "ID: %u QS: %d TS: %d", qca->Identifier, qstart, tstart);
2408 }
2409 else if (qstart > 1)
2410 {
2411 /* Shorter N-terminus (1*2**2=4) */
2412 if (tstart == 0)
2413 qca->Coverage += 4U;
2414 /* Non-matching N-terminus (0*2**1=0) */
2415 else if (tstart > 0)
2416 qca->Coverage += 0U;
2417 else
2418 ajWarn("Error in N-terminus query coverage scoring schema. "
2419 "ID: %u QS: %d TS: %d", qca->Identifier, qstart, tstart);
2420 }
2421 else
2422 ajWarn("Error in N-terminus query coverage scoring schema. "
2423 "ID: %u QS: %d TS: %d", qca->Identifier, qstart, tstart);
2424
2425 /* Test for completeness of the C-terminus. */
2426
2427 if (qend == (ajint) qlength)
2428 {
2429 /* Perfect C-terminus (1*2**11=2048) */
2430 if (tend == (ajint) tlength)
2431 qca->Coverage += 2048U;
2432 /* Added stop codon (1*2**9=512) */
2433 else if (tend == (ajint) (tlength - 1U))
2434 qca->Coverage += 512U;
2435 /* Longer C-terminus (1*2**3=8) */
2436 else if (tend < (ajint) (tlength - 1U))
2437 qca->Coverage += 8U;
2438 else
2439 ajWarn("Error in C-terminus coverage scoring schema. "
2440 "ID: %u QE: %d QL: %u TE: %d TL: %u",
2441 qca->Identifier, qend, qlength, tend, tlength);
2442 }
2443 else if (qend == (ajint) (qlength - 1U))
2444 {
2445 /* Missing stop codon (1*2**7=128) */
2446 if (tend == (ajint) tlength)
2447 qca->Coverage += 128U;
2448 /* Non-matching stop codon (1*2**5=32) */
2449 else if (tend == (ajint) (tlength - 1U))
2450 qca->Coverage += 32U;
2451 /* Non-matching C-terminus (0*2**2=0) */
2452 else if (tend < (ajint) (tlength - 1U))
2453 qca->Coverage += 0U;
2454 else
2455 ajWarn("Error in C-terminus coverage scoring schema. "
2456 "ID: %u QE: %d QL: %u TE: %d TL: %u",
2457 qca->Identifier, qend, qlength, tend, tlength);
2458 }
2459 else if (qend < (ajint) (qlength - 1U))
2460 {
2461 /* Shorter C-terminus (1*2**1=2) */
2462 if (tend == (ajint) tlength)
2463 qca->Coverage += 2U;
2464 /* Non-matching C-terminus (0*2**2=0) */
2465 else if (tend < (ajint) tlength)
2466 qca->Coverage += 0U;
2467 else
2468 ajWarn("Error in C-terminus coverage scoring schema. "
2469 "ID: %u QE: %d QL: %u TE: %d TL: %u",
2470 qca->Identifier, qend, qlength, tend, tlength);
2471 }
2472 else
2473 ajWarn("Error in C-terminus coverage scoring schema. "
2474 "ID: %u QE: %d QL: %u TE: %d TL: %u",
2475 qca->Identifier, qend, qlength, tend, tlength);
2476
2477 /*
2478 ** Test for sequence identity over the threshold identity value
2479 ** only for perfect N and C-termini.
2480 **
2481 ** (1*2**12 + 1*2**11 = 4096 + 2048 = 6144)
2482 ** Identity Threshold value (1*2**13=8192)
2483 */
2484
2485 if ((qca->Coverage & 6144U) && (qca->Identity >= identity))
2486 qca->Coverage += 8192U;
2487
2488 return ajTrue;
2489 }
2490
2491
2492
2493
2494 /* @func ensQcalignmentCalculateQueryCoverageQueryQuery ***********************
2495 **
2496 ** Compares and scores two Ensembl Quality Check Alignment objects based on the
2497 ** coverage of the query sequences in the alignment. The score is the sum of
2498 ** 5' and 3' properties, which can be 'longer', 'equal' or 'shorter' in respect
2499 ** to the coverage of the query in the second alignment.
2500 ** The first alignment is usually the genome alignment the second one the
2501 ** reference to test alignment.
2502 **
2503 ** @cc Bio::EnsEMBL::QC::Alignment::q2q_query_coverage
2504 ** @param [r] qca1 [const EnsPQcalignment]
2505 ** First Ensembl Quality Check Alignment
2506 ** @param [r] qca2 [const EnsPQcalignment]
2507 ** Second Ensembl Quality Check Alignment
2508 ** @param [u] Pscore [ajuint*] Coverage score address
2509 **
2510 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2511 **
2512 ** @release 6.4.0
2513 ** @@
2514 **
2515 ** Query to Query Comparison Criteria
2516 **
2517 ** Start Coordinate Criteria and Scores 2**n score
2518 **
2519 ** Q1S<Q2S ==> first query longer 5 32
2520 ** Q1S=Q2S ==> queries are equal 7 128
2521 ** Q1S>Q2S ==> first query shorter 3 8
2522 **
2523 ** End Coordinate Criteria and Scores 2**n score
2524 **
2525 ** Q1E>Q2E ==> first query longer 4 16
2526 ** Q1E=Q2E ==> queries are equal 6 64
2527 ** Q1E<Q2E ==> first query shorter 2 4
2528 **
2529 ******************************************************************************/
2530
ensQcalignmentCalculateQueryCoverageQueryQuery(const EnsPQcalignment qca1,const EnsPQcalignment qca2,ajuint * Pscore)2531 AjBool ensQcalignmentCalculateQueryCoverageQueryQuery(
2532 const EnsPQcalignment qca1,
2533 const EnsPQcalignment qca2,
2534 ajuint *Pscore)
2535 {
2536 ajint end1 = 0;
2537 ajint end2 = 0;
2538 ajint start1 = 0;
2539 ajint start2 = 0;
2540
2541 if (!qca1)
2542 return ajFalse;
2543
2544 if (!Pscore)
2545 return ajFalse;
2546
2547 *Pscore = 0;
2548
2549 /*
2550 ** If either of the Alignment objects has no target assigned, the score is
2551 ** automatically 0.
2552 */
2553
2554 if (!qca1->TargetSequence)
2555 return ajTrue;
2556
2557 if (!qca2)
2558 return ajTrue;
2559
2560 if (!qca2->TargetSequence)
2561 return ajTrue;
2562
2563 /* The first Alignment object is always defined. (1*2**0=1) */
2564
2565 *Pscore += 1U;
2566
2567 if (qca2)
2568 {
2569 /*
2570 ** Check whether the query Ensembl Quality Check Sequence object is
2571 ** the same in both Ensembl Quality Check Alignment objects.
2572 */
2573
2574 if (!ensQcsequenceMatch(qca1->QuerySequence, qca2->QuerySequence))
2575 {
2576 *Pscore = 0U;
2577
2578 return ajTrue;
2579 }
2580
2581 /* The second Alignment object is defined. (1*2**1=2) */
2582
2583 *Pscore += 2U;
2584
2585 /*
2586 ** Determine the relative orientation of the query sequences in the
2587 ** alignment.
2588 */
2589
2590 if (qca1->QueryStrand == qca2->QueryStrand)
2591 {
2592 /* Parallel query sequences. */
2593
2594 start1 = qca1->QueryStart;
2595 end1 = qca1->QueryEnd;
2596
2597 start2 = qca2->QueryStart;
2598 end2 = qca2->QueryEnd;
2599 }
2600 else
2601 {
2602 /* Anti-parallel query sequences. */
2603
2604 start1 = qca1->QueryStart;
2605 end1 = qca1->QueryEnd;
2606
2607 start2 = qca2->QueryEnd;
2608 end2 = qca2->QueryStart;
2609 }
2610
2611 /* Evaluate query start coordinates. */
2612
2613 /* The first alignment is longer. (1*2**5=32) */
2614 if (start1 < start2)
2615 *Pscore += 32U;
2616 /* The first alignment is as long as the second. (1*2**7=128) */
2617 else if (start1 == start2)
2618 *Pscore += 128U;
2619 /* The first alignment is shorter. (1*2**3=8) */
2620 else if (start1 > start2)
2621 *Pscore += 8U;
2622 else
2623 ajWarn("Unexpected query start coordinate relationship.");
2624
2625 /* Evaluate query end coordinates. */
2626
2627 /* The first alignment is longer. (1*2**4=16) */
2628 if (end1 > end2)
2629 *Pscore += 16U;
2630 /* The first alignment is as long as the second. (1*2**6=64) */
2631 else if (end1 == end2)
2632 *Pscore += 64U;
2633 /* The first alignment is shorter. (1*2**2=4) */
2634 else if (end1 < end2)
2635 *Pscore += 4U;
2636 else
2637 ajWarn("Unexpected query end coordinate releationship.");
2638 }
2639
2640 /*
2641 ** Test for perfect query coverage in genome alignments. See
2642 ** ensQcalignmentCalculateQueryCoverageProteinGenome and
2643 ** ensQcalignmentCalculateQueryCoverageDnaGenome for details.
2644 ** Since this method is called for the genome alignment, the test
2645 ** refers to the first alignment (qca1).
2646 */
2647
2648 /* Perfect N- or 5'-terminus (1*2**6=64) */
2649 if (qca1->Coverage & 64U)
2650 *Pscore += 512U;
2651
2652 /* Perfect C- or 3'-terminus (1*2**5=32) */
2653 if (qca1->Coverage & 32U)
2654 *Pscore += 256U;
2655
2656 return ajTrue;
2657 }
2658
2659
2660
2661
2662 /* @func ensQcalignmentCalculateQueryCoverageQueryTarget **********************
2663 **
2664 ** Calculates the alignment coverage score for the query sequence and sets it
2665 ** in the coverage attribute of an Ensembl Quality Check Alignment.
2666 **
2667 ** @cc Bio::EnsEMBL::QC::Alignment::query_coverage
2668 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
2669 ** @param [r] identity [float] Identity threshold
2670 ** @param [r] edge [ajuint] Edge threshold to classify cases where only few
2671 ** residues at the edge are different.
2672 **
2673 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2674 **
2675 ** @release 6.4.0
2676 ** @@
2677 **
2678 ** Query Alignment Coverage Schema
2679 **
2680 ** N-terminus and C-terminus are scored independently based on alignment
2681 ** coordinates of query and target sequences.
2682 **
2683 **
2684 ** 0 QS QE QL
2685 ** 0 \ \ Query / / TL
2686 ** \ |--|+++++++++++|--| /
2687 ** |----|+++++++++++|------|
2688 ** / Target \
2689 ** TS TE
2690 **
2691 **
2692 ******************************************************************************/
2693
ensQcalignmentCalculateQueryCoverageQueryTarget(EnsPQcalignment qca,float identity,ajuint edge)2694 AjBool ensQcalignmentCalculateQueryCoverageQueryTarget(
2695 EnsPQcalignment qca,
2696 float identity,
2697 ajuint edge)
2698 {
2699 AjBool result = AJFALSE;
2700
2701 EnsPQcdatabase qqcdb = NULL;
2702 EnsPQcdatabase tqcdb = NULL;
2703
2704 if (!qca)
2705 return ajFalse;
2706
2707 qqcdb = ensQcsequenceGetQcdatabase(qca->QuerySequence);
2708 tqcdb = ensQcsequenceGetQcdatabase(qca->TargetSequence);
2709
2710 switch (ensQcdatabaseGetClass(tqcdb))
2711 {
2712 case ensEQcdatabaseClassGenome:
2713
2714 switch (ensQcdatabaseGetType(qqcdb))
2715 {
2716 case ensEQcdatabaseTypeProtein:
2717
2718 result = ensQcalignmentCalculateQueryCoverageProteinGenome(
2719 qca,
2720 identity,
2721 edge);
2722
2723 break;
2724
2725 case ensEQcdatabaseTypeDNA:
2726
2727 result = ensQcalignmentCalculateQueryCoverageDnaGenome(
2728 qca,
2729 identity,
2730 edge);
2731
2732 break;
2733
2734 default:
2735
2736 ajWarn("Cannot calculate a query to genome alignment "
2737 "coverage for an Ensembl Quality Check Database of "
2738 "type '%s'.",
2739 ensQcdatabaseTypeToChar(
2740 ensQcdatabaseGetType(qqcdb)));
2741 }
2742
2743 break;
2744
2745 default:
2746
2747 switch (ensQcdatabaseGetType(qqcdb))
2748 {
2749 case ensEQcdatabaseTypeProtein:
2750
2751 result = ensQcalignmentCalculateQueryCoverageProteinProtein(
2752 qca,
2753 identity);
2754
2755 break;
2756
2757 case ensEQcdatabaseTypeDNA:
2758
2759 result = ensQcalignmentCalculateQueryCoverageDnaDna(
2760 qca,
2761 identity,
2762 edge);
2763
2764 break;
2765
2766 default:
2767
2768 ajWarn("Cannot calculate a query alignment "
2769 "coverage for an Ensembl Quality Check Database of "
2770 "type '%s'.",
2771 ensQcdatabaseTypeToChar(
2772 ensQcdatabaseGetType(qqcdb)));
2773 }
2774 }
2775
2776 return result;
2777 }
2778
2779
2780
2781
2782 /* @func ensQcalignmentCalculateTargetCoordinates *****************************
2783 **
2784 ** Caclulate target coordinates of an Ensembl Quality Check Alignment.
2785 **
2786 ** @cc Bio::EnsEMBL::QC::Alignment::target_coordinates
2787 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
2788 ** @param [wP] Pstart [ajint*] Start
2789 ** @param [wP] Pend [ajint*] End
2790 ** @param [wP] Pstrand [ajint*] Strand
2791 ** @param [wP] Plength [ajuint*] Length
2792 **
2793 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2794 **
2795 ** @release 6.4.0
2796 ** @@
2797 ******************************************************************************/
2798
ensQcalignmentCalculateTargetCoordinates(const EnsPQcalignment qca,ajint * Pstart,ajint * Pend,ajint * Pstrand,ajuint * Plength)2799 AjBool ensQcalignmentCalculateTargetCoordinates(const EnsPQcalignment qca,
2800 ajint *Pstart,
2801 ajint *Pend,
2802 ajint *Pstrand,
2803 ajuint *Plength)
2804 {
2805 if (!qca)
2806 return ajFalse;
2807
2808 if (!Pstart)
2809 return ajFalse;
2810
2811 if (!Pend)
2812 return ajFalse;
2813
2814 if (!Pstrand)
2815 return ajFalse;
2816
2817 if (!Plength)
2818 return ajFalse;
2819
2820 if (qca->TargetStrand >= 0)
2821 {
2822 *Pstart = qca->TargetStart;
2823 *Pend = qca->TargetEnd;
2824 }
2825 else
2826 {
2827 *Pstart = qca->TargetEnd;
2828 *Pend = qca->TargetStart;
2829 }
2830
2831 *Pstrand = qca->TargetStrand;
2832
2833 /* In Exonerate coordinates the length is just end - start. */
2834
2835 *Plength = *Pend - *Pstart;
2836
2837 return ajTrue;
2838 }
2839
2840
2841
2842
2843 /* @section check *************************************************************
2844 **
2845 ** Check Ensembl Quality Check Alignment objects.
2846 **
2847 ** @fdata [EnsPQcalignment]
2848 **
2849 ** @nam3rule Check Check Ensembl Quality Check Alignment objects
2850 ** @nam4rule Target Check the target Ensembl Quality Check Sequence object
2851 ** @nam5rule Overlap Check for target Ensembl Quality Check Sequence overlap
2852 **
2853 ** @argrule CheckTargetOverlap qca1 [const EnsPQcalignment]
2854 ** Ensembl Quality Check Alignment
2855 ** @argrule CheckTargetOverlap qca2 [const EnsPQcalignment]
2856 ** Ensembl Quality Check Alignment
2857 **
2858 ** @valrule * [AjBool] ajTrue on overlap, ajFalse otherwise
2859 **
2860 ** @fcategory use
2861 ******************************************************************************/
2862
2863
2864
2865
2866 /* @func ensQcalignmentCheckTargetOverlap *************************************
2867 **
2868 ** Check if two Ensembl Quality Check Alignment objects overlap on the target
2869 ** Ensembl Quality Check Sequence.
2870 ** The test checks for identical Ensembl Quality Check Sequences and takes
2871 ** strand information into account.
2872 **
2873 ** @cc Bio::EnsEMBL::QC::Alignment::overlap_on_target
2874 ** @param [r] qca1 [const EnsPQcalignment]
2875 ** First Ensembl Quality Check Sequence
2876 ** @param [r] qca2 [const EnsPQcalignment]
2877 ** Second Ensembl Quality Check Sequence
2878 **
2879 ** @return [AjBool] ajTrue on overlap, ajFalse otherwise
2880 **
2881 ** @release 6.4.0
2882 ** @@
2883 ******************************************************************************/
2884
ensQcalignmentCheckTargetOverlap(const EnsPQcalignment qca1,const EnsPQcalignment qca2)2885 AjBool ensQcalignmentCheckTargetOverlap(const EnsPQcalignment qca1,
2886 const EnsPQcalignment qca2)
2887 {
2888 ajint end1 = 0;
2889 ajint end2 = 0;
2890 ajint start1 = 0;
2891 ajint start2 = 0;
2892 ajint strand1 = 0;
2893 ajint strand2 = 0;
2894
2895 ajuint length1 = 0U;
2896 ajuint length2 = 0U;
2897
2898 if (!qca1)
2899 return ajFalse;
2900
2901 if (!qca2)
2902 return ajFalse;
2903
2904 /* Check for identical target sequence objects. */
2905
2906 if (!ensQcsequenceMatch(qca1->TargetSequence, qca2->TargetSequence))
2907 return ajFalse;
2908
2909 /* Check for identical target strands. */
2910
2911 if (qca1->TargetStrand != qca2->TargetStrand)
2912 return 0;
2913
2914 /*
2915 ** Determine the relative orientation of the target sequences in the
2916 ** alignment.
2917 */
2918
2919 ensQcalignmentCalculateTargetCoordinates(qca1,
2920 &start1,
2921 &end1,
2922 &strand1,
2923 &length1);
2924
2925 ensQcalignmentCalculateTargetCoordinates(qca2,
2926 &start2,
2927 &end2,
2928 &strand2,
2929 &length2);
2930
2931 /* Overlap criterion */
2932
2933 if ((start1 <= end2) && (end1 >= start2))
2934 return ajTrue;
2935
2936 return ajFalse;
2937 }
2938
2939
2940
2941
2942 /* @section report ************************************************************
2943 **
2944 ** Report Ensembl Quality Check Alignment objects.
2945 **
2946 ** @fdata [EnsPQcalignment]
2947 **
2948 ** @nam3rule Report Report Ensembl Quality Check Alignment objects
2949 **
2950 ** @argrule Report qca [const EnsPQcalignment] Ensembl Quality Check Alignment
2951 ** @argrule Report Pstr [AjPStr*] AJAX String
2952 ** @argrule Report internalquery [AjBool] HTML document-internal query link
2953 ** @argrule Report internaltarget [AjBool] HTML document-internal target link
2954 **
2955 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
2956 **
2957 ** @fcategory use
2958 ******************************************************************************/
2959
2960
2961
2962
2963 /* @func ensQcalignmentReport *************************************************
2964 **
2965 ** Report an Ensembl Quality Check Alignment in the following way:
2966 ** query:start-end:strand (length)
2967 ** target:start-end:strand (length)
2968 **
2969 ** @cc Bio::EnsEMBL::QC::Alignment::report
2970 ** @param [r] qca [const EnsPQcalignment]
2971 ** Ensembl Quality Check Alignment Adaptor
2972 ** @param [w] Pstr [AjPStr*] AJAX String
2973 ** @param [r] internalquery [AjBool] HTML document-internal query link
2974 ** @param [r] internaltarget [AjBool] HTML document-internal target link
2975 **
2976 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2977 **
2978 ** @release 6.2.0
2979 ** @@
2980 ******************************************************************************/
2981
ensQcalignmentReport(const EnsPQcalignment qca,AjPStr * Pstr,AjBool internalquery,AjBool internaltarget)2982 AjBool ensQcalignmentReport(const EnsPQcalignment qca,
2983 AjPStr *Pstr,
2984 AjBool internalquery,
2985 AjBool internaltarget)
2986 {
2987 ajint start = 0;
2988 ajint end = 0;
2989 ajint strand = 0;
2990
2991 ajuint length = 0U;
2992
2993 AjPStr anchor = NULL;
2994 AjPStr exturl = NULL;
2995 AjPStr location = NULL;
2996
2997 EnsPQcdatabase qcdb = NULL;
2998
2999 if (!qca)
3000 return ajFalse;
3001
3002 /* Format the query part of the Alignment object. */
3003
3004 ensQcalignmentCalculateQueryCoordinates(qca,
3005 &start,
3006 &end,
3007 &strand,
3008 &length);
3009
3010 qcdb = ensQcsequenceGetQcdatabase(qca->QuerySequence);
3011
3012 if (internalquery)
3013 {
3014 /* A HTML document-internal link is requested. */
3015
3016 anchor = ajStrNew();
3017
3018 ensQcsequenceFetchAnchorInternal(qca->QuerySequence, &anchor);
3019
3020 ajFmtPrintAppS(Pstr, "%S:%d-%d:%d", anchor, start, end, strand);
3021
3022 ajStrDel(&anchor);
3023 }
3024 else if (ensQcdatabaseGetUrlExternal(qcdb))
3025 {
3026 /* An URL has been set in the sequence database definition. */
3027
3028 exturl = ajStrNewS(ensQcdatabaseGetUrlExternal(qcdb));
3029
3030 if (ajStrFindC(exturl, "###LOCATION###"))
3031 {
3032 /* ###LOCATION### links to Location/View. */
3033
3034 location = ajFmtStr("%S:%d-%d",
3035 ensQcsequenceGetName(qca->QuerySequence),
3036 start,
3037 end);
3038
3039 ajStrExchangeCS(&exturl, "###LOCATION###", location);
3040
3041 ensHtmlEncodeEntities(&exturl);
3042
3043 ajFmtPrintAppS(Pstr,
3044 "<a href=\"%S\" target=\"external\">%S</a>:%d",
3045 exturl,
3046 location,
3047 strand);
3048
3049 ajStrDel(&location);
3050 }
3051 else
3052 {
3053 /* Conventional URL replacement. */
3054
3055 anchor = ajStrNew();
3056
3057 ensQcsequenceFetchAnchorExternal(qca->QuerySequence,
3058 ajFalse,
3059 &anchor);
3060
3061 ajFmtPrintAppS(Pstr,
3062 "%S:%d-%d:%d",
3063 anchor,
3064 start,
3065 end,
3066 strand);
3067
3068 ajStrDel(&anchor);
3069 }
3070
3071 ajStrDel(&exturl);
3072 }
3073 else
3074 {
3075 /* No URL just plain text. */
3076
3077 ajFmtPrintAppS(Pstr,
3078 "%S:%d-%d:%d",
3079 ensQcsequenceGetName(qca->QuerySequence),
3080 start,
3081 end,
3082 strand);
3083 }
3084
3085 ajFmtPrintAppS(Pstr, " (%d)", length);
3086
3087 if (!qca->TargetSequence)
3088 return ajTrue;
3089
3090 /* Format the target part of the Alignment object. */
3091
3092 ensQcalignmentCalculateTargetCoordinates(qca,
3093 &start,
3094 &end,
3095 &strand,
3096 &length);
3097
3098 qcdb = ensQcsequenceGetQcdatabase(qca->TargetSequence);
3099
3100 ajStrAppendC(Pstr, "\t");
3101
3102 if (internaltarget)
3103 {
3104 /* A HTML document-internal link has been requested. */
3105
3106 anchor = ajStrNew();
3107
3108 ensQcsequenceFetchAnchorInternal(qca->TargetSequence, &anchor);
3109
3110 ajFmtPrintAppS(Pstr, "%S:%d-%d:%d", anchor, start, end, strand);
3111
3112 ajStrDel(&anchor);
3113 }
3114 else if (ensQcdatabaseGetUrlExternal(qcdb))
3115 {
3116 /* URL has been set in the sequence database definition. */
3117
3118 exturl = ajStrNewS(ensQcdatabaseGetUrlExternal(qcdb));
3119
3120 if (ajStrFindC(exturl, "###LOCATION###"))
3121 {
3122
3123 /* ###LOCATION### links to Location/View. */
3124
3125 location = ajFmtStr("%S:%d-%d",
3126 ensQcsequenceGetName(qca->TargetSequence),
3127 start,
3128 end);
3129
3130 ajStrExchangeCS(&exturl, "###LOCATION###", location);
3131
3132 ensHtmlEncodeEntities(&exturl);
3133
3134 ajFmtPrintAppS(Pstr,
3135 "<a href=\"%S\" target=\"external\">%S</a>:%d",
3136 exturl,
3137 location,
3138 strand);
3139
3140 ajStrDel(&location);
3141 }
3142 else
3143 {
3144 /* Conventional URL replacement. */
3145
3146 anchor = ajStrNew();
3147
3148 ensQcsequenceFetchAnchorExternal(qca->TargetSequence,
3149 ajFalse,
3150 &anchor);
3151
3152 ajFmtPrintAppS(Pstr,
3153 "%S:%d-%d:%d",
3154 anchor,
3155 start,
3156 end,
3157 strand);
3158
3159 ajStrDel(&anchor);
3160 }
3161
3162 ajStrDel(&exturl);
3163 }
3164 else
3165 {
3166 /* No URL just plain text. */
3167
3168 ajFmtPrintAppS(Pstr,
3169 "%S:%d-%d:%d",
3170 ensQcsequenceGetName(qca->TargetSequence),
3171 start,
3172 end,
3173 strand);
3174 }
3175
3176 ajFmtPrintAppS(Pstr, " (%d)", length);
3177
3178 return ajTrue;
3179 }
3180
3181
3182
3183
3184 /* @datasection [EnsPQcalignmentadaptor] Ensembl Quality Check Alignment
3185 ** Adaptor
3186 **
3187 ** @nam2rule Qcalignmentadaptor Functions for manipulating
3188 ** Ensembl Quality Check Alignment Adaptor objects
3189 **
3190 ** @cc Bio::EnsEMBL::QC::DBSQL::Alignmentadaptor
3191 ** @cc CVS Revision:
3192 ** @cc CVS Tag:
3193 **
3194 ******************************************************************************/
3195
3196
3197
3198
3199 /* @funcstatic qcalignmentadaptorFetchAllbyStatement **************************
3200 **
3201 ** Run a SQL statement against an Ensembl Database Adaptor and consolidate the
3202 ** results into an AJAX List of Ensembl Quality Check Alignment objects.
3203 **
3204 ** @param [u] ba [EnsPBaseadaptor] Ensembl Base Adaptor
3205 ** @param [r] statement [const AjPStr] SQL statement
3206 ** @param [uN] am [EnsPAssemblymapper] Ensembl Assembly Mapper
3207 ** @param [uN] slice [EnsPSlice] Ensembl Slice
3208 ** @param [u] qcas [AjPList] AJAX List of
3209 ** Ensembl Quality Check Alignment objects
3210 **
3211 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3212 **
3213 ** @release 6.4.0
3214 ** @@
3215 ******************************************************************************/
3216
qcalignmentadaptorFetchAllbyStatement(EnsPBaseadaptor ba,const AjPStr statement,EnsPAssemblymapper am,EnsPSlice slice,AjPList qcas)3217 static AjBool qcalignmentadaptorFetchAllbyStatement(
3218 EnsPBaseadaptor ba,
3219 const AjPStr statement,
3220 EnsPAssemblymapper am,
3221 EnsPSlice slice,
3222 AjPList qcas)
3223 {
3224 double score = 0.0;
3225 float identity = 0.0F;
3226
3227 ajint qstrand = 0;
3228 ajint tstrand = 0;
3229 ajint sstrand = 0;
3230
3231 ajuint identifier = 0U;
3232 ajuint analysisid = 0U;
3233 ajuint coverage = 0U;
3234 ajuint qdbid = 0U;
3235 ajuint qsid = 0U;
3236 ajuint qstart = 0U;
3237 ajuint qend = 0U;
3238 ajuint tdbid = 0U;
3239 ajuint tsid = 0U;
3240 ajuint tstart = 0U;
3241 ajuint tend = 0U;
3242
3243 AjPSqlstatement sqls = NULL;
3244 AjISqlrow sqli = NULL;
3245 AjPSqlrow sqlr = NULL;
3246
3247 AjPStr vulgar = NULL;
3248
3249 EnsPAnalysis analysis = NULL;
3250 EnsPAnalysisadaptor aa = NULL;
3251
3252 EnsPDatabaseadaptor dba = NULL;
3253
3254 EnsPQcalignment qca = NULL;
3255 EnsPQcalignmentadaptor qcaa = NULL;
3256
3257 EnsPQcsequence qsequence = NULL;
3258 EnsPQcsequence tsequence = NULL;
3259 EnsPQcsequenceadaptor qcsa = NULL;
3260
3261 if (ajDebugTest("qcalignmentadaptorFetchAllbyStatement"))
3262 ajDebug("qcalignmentadaptorFetchAllbyStatement\n"
3263 " ba %p\n"
3264 " statement %p\n"
3265 " am %p\n"
3266 " slice %p\n"
3267 " qcas %p\n",
3268 ba,
3269 statement,
3270 am,
3271 slice,
3272 qcas);
3273
3274 if (!ba)
3275 return ajFalse;
3276
3277 if (!statement)
3278 return ajFalse;
3279
3280 if (!qcas)
3281 return ajFalse;
3282
3283 dba = ensBaseadaptorGetDatabaseadaptor(ba);
3284
3285 aa = ensRegistryGetAnalysisadaptor(dba);
3286 qcaa = ensRegistryGetQcalignmentadaptor(dba);
3287 qcsa = ensRegistryGetQcsequenceadaptor(dba);
3288
3289 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
3290
3291 sqli = ajSqlrowiterNew(sqls);
3292
3293 while (!ajSqlrowiterDone(sqli))
3294 {
3295 identifier = 0;
3296 analysisid = 0;
3297 qdbid = 0;
3298 qsid = 0;
3299 qstart = 0;
3300 qend = 0;
3301 qstrand = 0;
3302 tdbid = 0;
3303 tsid = 0;
3304 tstart = 0;
3305 tend = 0;
3306 tstrand = 0;
3307 sstrand = 0;
3308 score = 0.0;
3309 identity = 0.0F;
3310 vulgar = ajStrNew();
3311 coverage = 0;
3312
3313 sqlr = ajSqlrowiterGet(sqli);
3314
3315 ajSqlcolumnToUint(sqlr, &identifier);
3316 ajSqlcolumnToUint(sqlr, &analysisid);
3317 ajSqlcolumnToUint(sqlr, &qdbid);
3318 ajSqlcolumnToUint(sqlr, &qsid);
3319 ajSqlcolumnToUint(sqlr, &qstart);
3320 ajSqlcolumnToUint(sqlr, &qend);
3321 ajSqlcolumnToInt(sqlr, &qstrand);
3322 ajSqlcolumnToUint(sqlr, &tdbid);
3323 ajSqlcolumnToUint(sqlr, &tsid);
3324 ajSqlcolumnToUint(sqlr, &tstart);
3325 ajSqlcolumnToUint(sqlr, &tend);
3326 ajSqlcolumnToInt(sqlr, &tstrand);
3327 ajSqlcolumnToInt(sqlr, &sstrand);
3328 ajSqlcolumnToDouble(sqlr, &score);
3329 ajSqlcolumnToFloat(sqlr, &identity);
3330 ajSqlcolumnToStr(sqlr, &vulgar);
3331 ajSqlcolumnToUint(sqlr, &coverage);
3332
3333 ensAnalysisadaptorFetchByIdentifier(aa, analysisid, &analysis);
3334
3335 ensQcsequenceadaptorFetchByIdentifier(qcsa, qsid, &qsequence);
3336
3337 ensQcsequenceadaptorFetchByIdentifier(qcsa, tsid, &tsequence);
3338
3339 qca = ensQcalignmentNewIni(qcaa,
3340 identifier,
3341 analysis,
3342 qsequence,
3343 qstart,
3344 qend,
3345 qstrand,
3346 tsequence,
3347 tstart,
3348 tend,
3349 tstrand,
3350 sstrand,
3351 coverage,
3352 score,
3353 identity,
3354 vulgar);
3355
3356 ajListPushAppend(qcas, (void *) qca);
3357
3358 ensQcsequenceDel(&qsequence);
3359
3360 ensQcsequenceDel(&tsequence);
3361
3362 ensAnalysisDel(&analysis);
3363
3364 ajStrDel(&vulgar);
3365 }
3366
3367 ajSqlrowiterDel(&sqli);
3368
3369 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
3370
3371 return ajTrue;
3372 }
3373
3374
3375
3376
3377 /* @section constructors ******************************************************
3378 **
3379 ** All constructors return a new Ensembl Quality Check Alignment Adaptor by
3380 ** pointer. It is the responsibility of the user to first destroy any previous
3381 ** Quality Check Alignment Adaptor. The target pointer does not need to be
3382 ** initialised to NULL, but it is good programming practice to do so anyway.
3383 **
3384 ** @fdata [EnsPQcalignmentadaptor]
3385 **
3386 ** @nam3rule New Constructor
3387 **
3388 ** @argrule New dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3389 **
3390 ** @valrule * [EnsPQcalignmentadaptor]
3391 ** Ensembl Quality Check Alignment Adaptor or NULL
3392 **
3393 ** @fcategory new
3394 ******************************************************************************/
3395
3396
3397
3398
3399 /* @func ensQcalignmentadaptorNew *********************************************
3400 **
3401 ** Default constructor for an Ensembl Quality Check Alignment Adaptor.
3402 **
3403 ** Ensembl Object Adaptors are singleton objects in the sense that a single
3404 ** instance of an Ensembl Object Adaptor connected to a particular database is
3405 ** sufficient to instantiate any number of Ensembl Objects from the database.
3406 ** Each Ensembl Object will have a weak reference to the Object Adaptor that
3407 ** instantiated it. Therefore, Ensembl Object Adaptors should not be
3408 ** instantiated directly, but rather obtained from the Ensembl Registry,
3409 ** which will in turn call this function if neccessary.
3410 **
3411 ** @see ensRegistryGetDatabaseadaptor
3412 ** @see ensRegistryGetQcalignmentadaptor
3413 **
3414 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3415 **
3416 ** @return [EnsPQcalignmentadaptor]
3417 ** Ensembl Quality Check Alignment Adaptor or NULL
3418 **
3419 ** @release 6.2.0
3420 ** @@
3421 ******************************************************************************/
3422
ensQcalignmentadaptorNew(EnsPDatabaseadaptor dba)3423 EnsPQcalignmentadaptor ensQcalignmentadaptorNew(
3424 EnsPDatabaseadaptor dba)
3425 {
3426 return ensBaseadaptorNew(
3427 dba,
3428 qcalignmentadaptorKTablenames,
3429 qcalignmentadaptorKColumnnames,
3430 (const EnsPBaseadaptorLeftjoin) NULL,
3431 (const char *) NULL,
3432 (const char *) NULL,
3433 &qcalignmentadaptorFetchAllbyStatement);
3434 }
3435
3436
3437
3438
3439 /* @section destructors *******************************************************
3440 **
3441 ** Destruction destroys all internal data structures and frees the memory
3442 ** allocated for an Ensembl Quality Check Alignment Adaptor object.
3443 **
3444 ** @fdata [EnsPQcalignmentadaptor]
3445 **
3446 ** @nam3rule Del Destroy (free) an Ensembl Quality Check Alignment Adaptor
3447 **
3448 ** @argrule * Pqcaa [EnsPQcalignmentadaptor*]
3449 ** Ensembl Quality Check Alignment Adaptor address
3450 **
3451 ** @valrule * [void]
3452 **
3453 ** @fcategory delete
3454 ******************************************************************************/
3455
3456
3457
3458
3459 /* @func ensQcalignmentadaptorDel *********************************************
3460 **
3461 ** Default destructor for an Ensembl Quality Check Alignment Adaptor.
3462 **
3463 ** Ensembl Object Adaptors are singleton objects that are registered in the
3464 ** Ensembl Registry and weakly referenced by Ensembl Objects that have been
3465 ** instantiated by it. Therefore, Ensembl Object Adaptors should never be
3466 ** destroyed directly. Upon exit, the Ensembl Registry will call this function
3467 ** if required.
3468 **
3469 ** @param [d] Pqcaa [EnsPQcalignmentadaptor*]
3470 ** Ensembl Quality Check Alignment Adaptor address
3471 **
3472 ** @return [void]
3473 **
3474 ** @release 6.2.0
3475 ** @@
3476 ******************************************************************************/
3477
ensQcalignmentadaptorDel(EnsPQcalignmentadaptor * Pqcaa)3478 void ensQcalignmentadaptorDel(EnsPQcalignmentadaptor *Pqcaa)
3479 {
3480 ensBaseadaptorDel(Pqcaa);
3481
3482 return;
3483 }
3484
3485
3486
3487
3488 /* @section member retrieval **************************************************
3489 **
3490 ** Functions for returning members of an
3491 ** Ensembl Quality Check Alignment Adaptor object.
3492 **
3493 ** @fdata [EnsPQcalignmentadaptor]
3494 **
3495 ** @nam3rule Get Return Ensembl Quality Check Alignment Adaptor attribute(s)
3496 ** @nam4rule Baseadaptor Return the Ensembl Base Adaptor
3497 ** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
3498 **
3499 ** @argrule * qcaa [EnsPQcalignmentadaptor]
3500 ** Ensembl Quality Check Alignment Adaptor
3501 **
3502 ** @valrule Baseadaptor [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
3503 ** @valrule Databaseadaptor [EnsPDatabaseadaptor] Ensembl Database Adaptor
3504 ** or NULL
3505 **
3506 ** @fcategory use
3507 ******************************************************************************/
3508
3509
3510
3511
3512 /* @func ensQcalignmentadaptorGetBaseadaptor **********************************
3513 **
3514 ** Get the Ensembl Base Adaptor member of an
3515 ** Ensembl Quality Check Alignment Adaptor.
3516 **
3517 ** @param [u] qcaa [EnsPQcalignmentadaptor]
3518 ** Ensembl Quality Check Alignment Adaptor
3519 **
3520 ** @return [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
3521 **
3522 ** @release 6.4.0
3523 ** @@
3524 ******************************************************************************/
3525
ensQcalignmentadaptorGetBaseadaptor(EnsPQcalignmentadaptor qcaa)3526 EnsPBaseadaptor ensQcalignmentadaptorGetBaseadaptor(
3527 EnsPQcalignmentadaptor qcaa)
3528 {
3529 return qcaa;
3530 }
3531
3532
3533
3534
3535 /* @func ensQcalignmentadaptorGetDatabaseadaptor ******************************
3536 **
3537 ** Get the Ensembl Database Adaptor member of an
3538 ** Ensembl Quality Check Alignment Adaptor.
3539 **
3540 ** @param [u] qcaa [EnsPQcalignmentadaptor]
3541 ** Ensembl Quality Check Alignment Adaptor
3542 **
3543 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
3544 **
3545 ** @release 6.4.0
3546 ** @@
3547 ******************************************************************************/
3548
ensQcalignmentadaptorGetDatabaseadaptor(EnsPQcalignmentadaptor qcaa)3549 EnsPDatabaseadaptor ensQcalignmentadaptorGetDatabaseadaptor(
3550 EnsPQcalignmentadaptor qcaa)
3551 {
3552 return ensBaseadaptorGetDatabaseadaptor(
3553 ensQcalignmentadaptorGetBaseadaptor(qcaa));
3554 }
3555
3556
3557
3558
3559 /* @section object retrieval **************************************************
3560 **
3561 ** Functions for fetching Ensembl Quality Check Alignment objects from an
3562 ** Ensembl SQL database.
3563 **
3564 ** @fdata [EnsPQcalignmentadaptor]
3565 **
3566 ** @nam3rule Fetch Fetch Ensembl Quality Check Alignment object(s)
3567 ** @nam4rule All Fetch all Ensembl Quality Check Alignment objects
3568 ** @nam4rule Allby Fetch all Ensembl Quality Check Alignment objects matching a
3569 ** criterion
3570 ** @nam5rule Coverage Fetch all by a coverage score
3571 ** @nam5rule Location Fetch all by a location
3572 ** @nam6rule Target Fetch all by a location on the target
3573 ** @nam5rule Qcdatabase Fetch all by an Ensembl Quality Check Database
3574 ** @nam6rule Pair Fetch all by an Ensembl Quality Check Database pair
3575 ** @nam6rule Query Fetch all by an Ensembl Quality Check Database
3576 ** as query
3577 ** @nam6rule Target Fetch all by an Ensembl Quality Check Database
3578 ** as target
3579 ** @nam5rule Region Fetch all by a region
3580 ** @nam4rule By Fetch one Ensembl Quality Check Alignment object
3581 ** matching a criterion
3582 ** @nam5rule Identifier Fetch by an SQL database internal identifier
3583 **
3584 ** @argrule * qcaa [EnsPQcalignmentadaptor]
3585 ** Ensembl Quality Check Alignment Adaptor
3586 ** @argrule AllbyCoverage lower [ajuint] Lower coverage score
3587 ** @argrule AllbyCoverage upper [ajuint] Upper coverage score
3588 ** @argrule AllbyCoverage qcas [AjPList] AJAX List of
3589 ** Ensembl Quality Check Alignment objects
3590 ** @argrule AllbyLocationTarget analysis [const EnsPAnalysis] Ensembl Analysis
3591 ** @argrule AllbyLocationTarget tsequence [const EnsPQcsequence]
3592 ** Target Ensembl Quality Check Sequence
3593 ** @argrule AllbyLocationTarget tstart [ajuint] Target start
3594 ** @argrule AllbyLocationTarget tend [ajuint] Target end
3595 ** @argrule AllbyLocationTarget qcas [AjPList] AJAX List of
3596 ** Ensembl Quality Check Alignment objects
3597 ** @argrule AllbyQcdatabasePair analysis [const EnsPAnalysis] Ensembl Analysis
3598 ** @argrule AllbyQcdatabasePair qdb [const EnsPQcdatabase]
3599 ** Query Ensembl Quality Check Database
3600 ** @argrule AllbyQcdatabasePair tdb [const EnsPQcdatabase]
3601 ** Target Ensembl Quality Check Database
3602 ** @argrule AllbyQcdatabasePair qcas [AjPList] AJAX List of
3603 ** Ensembl Quality Check Alignment objects
3604 ** @argrule AllbyQcdatabaseQuery analysis [const EnsPAnalysis] Ensembl Analysis
3605 ** @argrule AllbyQcdatabaseQuery qdb [const EnsPQcdatabase]
3606 ** Query Ensembl Quality Check Database
3607 ** @argrule AllbyQcdatabaseQuery qcas [AjPList] AJAX List of
3608 ** Ensembl Quality Check Alignment objects
3609 ** @argrule AllbyQcdatabaseTarget analysis [const EnsPAnalysis]
3610 ** Ensembl Analysis
3611 ** @argrule AllbyQcdatabaseTarget tdb [const EnsPQcdatabase]
3612 ** Target Ensembl Quality Check Database
3613 ** @argrule AllbyQcdatabaseTarget qcas [AjPList] AJAX List of
3614 ** Ensembl Quality Check Alignment objects
3615 ** @argrule AllbyRegion analysis [const EnsPAnalysis] Ensembl Analysis
3616 ** @argrule AllbyRegion qsequence [const EnsPQcsequence]
3617 ** Query Ensembl Quality Check Sequence
3618 ** @argrule AllbyRegion tdb [const EnsPQcdatabase]
3619 ** Target Ensembl Quality Check Database
3620 ** @argrule AllbyRegion tsequence [const EnsPQcsequence]
3621 ** Target Ensembl Quality Check Sequence
3622 ** @argrule AllbyRegion tstart [ajuint] Target start
3623 ** @argrule AllbyRegion tend [ajuint] Target end
3624 ** @argrule AllbyRegion tstrand [ajint] Target strand
3625 ** @argrule AllbyRegion qcsbs [AjPList] AJAX List of
3626 ** Ensembl Quality Check Alignment objects
3627 ** @argrule ByIdentifier identifier [ajuint] SQL database-internal identifier
3628 ** @argrule ByIdentifier Pqca [EnsPQcalignment*]
3629 ** Ensembl Quality Check Alignment address
3630 **
3631 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3632 **
3633 ** @fcategory use
3634 ******************************************************************************/
3635
3636
3637
3638
3639 /* @func ensQcalignmentadaptorFetchAllbyCoverage ******************************
3640 **
3641 ** Fetch all Ensembl Quality Check Alignment objects by a coverage score range.
3642 ** The caller is responsible for deleting the Ensembl Quality Check Alignment
3643 ** objects before deleting the AJAX List.
3644 **
3645 ** @param [u] qcaa [EnsPQcalignmentadaptor]
3646 ** Ensembl Quality Check Alignment Adaptor
3647 ** @param [r] lower [ajuint] Lower coverage score
3648 ** @param [r] upper [ajuint] Upper coverage score
3649 ** @param [u] qcas [AjPList] AJAX List of Ensembl Quality Check Alignment objects
3650 **
3651 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3652 **
3653 ** @release 6.4.0
3654 ** @@
3655 ******************************************************************************/
3656
ensQcalignmentadaptorFetchAllbyCoverage(EnsPQcalignmentadaptor qcaa,ajuint lower,ajuint upper,AjPList qcas)3657 AjBool ensQcalignmentadaptorFetchAllbyCoverage(EnsPQcalignmentadaptor qcaa,
3658 ajuint lower,
3659 ajuint upper,
3660 AjPList qcas)
3661 {
3662 AjBool result = AJFALSE;
3663
3664 AjPStr constraint = NULL;
3665
3666 if (!qcaa)
3667 return ajFalse;
3668
3669 if (!qcas)
3670 return ajFalse;
3671
3672 constraint = ajFmtStr("alignment.coverage >= %u "
3673 "AND "
3674 "alignment.coverage <= %u",
3675 lower, upper);
3676
3677 result = ensBaseadaptorFetchAllbyConstraint(
3678 ensQcalignmentadaptorGetBaseadaptor(qcaa),
3679 constraint,
3680 (EnsPAssemblymapper) NULL,
3681 (EnsPSlice) NULL,
3682 qcas);
3683
3684 ajStrDel(&constraint);
3685
3686 return result;
3687 }
3688
3689
3690
3691
3692 /* @func ensQcalignmentadaptorFetchAllbyLocationTarget ************************
3693 **
3694 ** Fetch all Ensembl Quality Check Alignment objects by a target location.
3695 **
3696 ** The caller is responsible for deleting the Ensembl Quality Check Alignment
3697 ** objects before deleting the AJAX List.
3698 **
3699 ** @param [u] qcaa [EnsPQcalignmentadaptor]
3700 ** Ensembl Quality Check Alignment Adaptor
3701 ** @param [r] analysis [const EnsPAnalysis] Ensembl Analysis
3702 ** @param [r] tsequence [const EnsPQcsequence]
3703 ** Target Ensembl Quality Check Sequence
3704 ** @param [r] tstart [ajuint] Target start
3705 ** @param [r] tend [ajuint] Target end
3706 ** @param [u] qcas [AjPList] AJAX List of
3707 ** Ensembl Quality Check Alignment objects
3708 **
3709 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3710 **
3711 ** @release 6.4.0
3712 ** @@
3713 ******************************************************************************/
3714
ensQcalignmentadaptorFetchAllbyLocationTarget(EnsPQcalignmentadaptor qcaa,const EnsPAnalysis analysis,const EnsPQcsequence tsequence,ajuint tstart,ajuint tend,AjPList qcas)3715 AjBool ensQcalignmentadaptorFetchAllbyLocationTarget(
3716 EnsPQcalignmentadaptor qcaa,
3717 const EnsPAnalysis analysis,
3718 const EnsPQcsequence tsequence,
3719 ajuint tstart,
3720 ajuint tend,
3721 AjPList qcas)
3722 {
3723 AjBool result = AJFALSE;
3724
3725 AjPStr constraint = NULL;
3726
3727 if (!qcaa)
3728 return ajFalse;
3729
3730 if (!analysis)
3731 return ajFalse;
3732
3733 if (!tsequence)
3734 return ajFalse;
3735
3736 if (!qcas)
3737 return ajFalse;
3738
3739 /*
3740 ** Sometimes things can get complicated. There are four scenarios possible.
3741 **
3742 ** 1. The feature start (fs) and feature end (fe) are both within
3743 ** target start (ss) and target end (se).
3744 ** This case is also covered by the combination of cases 2 and 3.
3745 **
3746 ** (fs>=ss AND fe<=se)
3747 **
3748 ** 2. Feature start is within target start and target end.
3749 **
3750 ** (fs>=ss AND fs<=se)
3751 **
3752 ** 3. Feature end is within target start and target end.
3753 **
3754 ** (fe>=ss AND fe<=se)
3755 **
3756 ** 4. The feature spans the target, but both ends are outside.
3757 **
3758 ** (fs<=ss AND fe>=se)
3759 **
3760 ** We want all features that fulfil either of the criteria.
3761 **
3762 ** Since Ensembl Quality Check Alignment object use the exonerate
3763 ** coordinate system, features on the reverse strand have a target start
3764 ** greater than the target end. Therefore, one SQL query per strand is
3765 ** required.
3766 */
3767
3768 constraint = ajFmtStr(
3769 "alignment.analysis_id = %u "
3770 "AND "
3771 "alignment.target_id = %u "
3772 "AND "
3773 "alignment.target_strand >= 0 "
3774 "AND "
3775 "("
3776 "(alignment.target_start >= %u AND alignment.target_start <= %u) "
3777 "OR "
3778 "(alignment.target_end >= %u AND alignment.target_end <= %u) "
3779 "OR "
3780 "(alignment.target_start <= %u AND alignment.target_end >= %u)"
3781 ")",
3782 ensAnalysisGetIdentifier(analysis),
3783 ensQcsequenceGetIdentifier(tsequence),
3784 tstart,
3785 tend,
3786 tstart,
3787 tend,
3788 tstart,
3789 tend);
3790
3791 result = ensBaseadaptorFetchAllbyConstraint(
3792 ensQcalignmentadaptorGetBaseadaptor(qcaa),
3793 constraint,
3794 (EnsPAssemblymapper) NULL,
3795 (EnsPSlice) NULL,
3796 qcas);
3797
3798 ajStrDel(&constraint);
3799
3800 constraint = ajFmtStr(
3801 "alignment.analysis_id = %u "
3802 "AND "
3803 "alignment.target_id = %u "
3804 "AND "
3805 "alignment.target_strand < 0 "
3806 "AND "
3807 "("
3808 "(alignment.target_end >= %u AND alignment.target_end <= %u) "
3809 "OR "
3810 "(alignment.target_start >= %u AND alignment.target_start <= %u) "
3811 "OR "
3812 "(alignment.target_end <= %u AND alignment.target_start >= %u)"
3813 ")",
3814 ensAnalysisGetIdentifier(analysis),
3815 ensQcsequenceGetIdentifier(tsequence),
3816 tstart,
3817 tend,
3818 tstart,
3819 tend,
3820 tstart,
3821 tend);
3822
3823 result = ensBaseadaptorFetchAllbyConstraint(
3824 ensQcalignmentadaptorGetBaseadaptor(qcaa),
3825 constraint,
3826 (EnsPAssemblymapper) NULL,
3827 (EnsPSlice) NULL,
3828 qcas);
3829
3830 ajStrDel(&constraint);
3831
3832 return result;
3833 }
3834
3835
3836
3837
3838 /* @func ensQcalignmentadaptorFetchAllbyQcdatabasePair ************************
3839 **
3840 ** Fetch all Ensembl Quality Check Alignment objects by Ensembl an Analysis,
3841 ** as well as query and target Ensembl Sequences.
3842 ** The caller is responsible for deleting the Ensembl Quality Check Alignment
3843 ** objects before deleting the AJAX List.
3844 **
3845 ** @param [u] qcaa [EnsPQcalignmentadaptor]
3846 ** Ensembl Quality Check Alignment Adaptor
3847 ** @param [r] analysis [const EnsPAnalysis] Ensembl Analysis
3848 ** @param [r] qdb [const EnsPQcdatabase] Query Ensembl Quality Check Database
3849 ** @param [r] tdb [const EnsPQcdatabase] Target Ensembl Quality Check Database
3850 ** @param [u] qcas [AjPList] AJAX List of
3851 ** Ensembl Quality Check Alignment objects
3852 **
3853 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3854 **
3855 ** @release 6.4.0
3856 ** @@
3857 ******************************************************************************/
3858
ensQcalignmentadaptorFetchAllbyQcdatabasePair(EnsPQcalignmentadaptor qcaa,const EnsPAnalysis analysis,const EnsPQcdatabase qdb,const EnsPQcdatabase tdb,AjPList qcas)3859 AjBool ensQcalignmentadaptorFetchAllbyQcdatabasePair(
3860 EnsPQcalignmentadaptor qcaa,
3861 const EnsPAnalysis analysis,
3862 const EnsPQcdatabase qdb,
3863 const EnsPQcdatabase tdb,
3864 AjPList qcas)
3865 {
3866 AjBool result = AJFALSE;
3867
3868 AjPStr constraint = NULL;
3869
3870 if (!qcaa)
3871 return ajFalse;
3872
3873 if (!analysis)
3874 return ajFalse;
3875
3876 if (!qdb)
3877 return ajFalse;
3878
3879 if (!tdb)
3880 return ajFalse;
3881
3882 if (!qcas)
3883 return ajFalse;
3884
3885 constraint = ajFmtStr("alignment.analysis_id = %u "
3886 "AND "
3887 "alignment.query_db_id = %u "
3888 "AND "
3889 "alignment.target_db_id = %u",
3890 ensAnalysisGetIdentifier(analysis),
3891 ensQcdatabaseGetIdentifier(qdb),
3892 ensQcdatabaseGetIdentifier(tdb));
3893
3894 result = ensBaseadaptorFetchAllbyConstraint(
3895 ensQcalignmentadaptorGetBaseadaptor(qcaa),
3896 constraint,
3897 (EnsPAssemblymapper) NULL,
3898 (EnsPSlice) NULL,
3899 qcas);
3900
3901 ajStrDel(&constraint);
3902
3903 return result;
3904 }
3905
3906
3907
3908
3909 /* @func ensQcalignmentadaptorFetchAllbyQcdatabaseQuery ***********************
3910 **
3911 ** Fetch all Ensembl Quality Check Alignment objects by a
3912 ** Query Ensembl Quality Check Sequence.
3913 ** The caller is responsible for deleting the Ensembl Quality Check Alignment
3914 ** objects before deleting the AJAX List.
3915 **
3916 ** @param [u] qcaa [EnsPQcalignmentadaptor]
3917 ** Ensembl Quality Check Alignment Adaptor
3918 ** @param [rN] analysis [const EnsPAnalysis] Ensembl Analysis
3919 ** @param [r] qdb [const EnsPQcdatabase] Query Ensembl Quality Check Database
3920 ** @param [u] qcas [AjPList] AJAX List of
3921 ** Ensembl Quality Check Alignment objects
3922 **
3923 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3924 **
3925 ** @release 6.4.0
3926 ** @@
3927 ******************************************************************************/
3928
ensQcalignmentadaptorFetchAllbyQcdatabaseQuery(EnsPQcalignmentadaptor qcaa,const EnsPAnalysis analysis,const EnsPQcdatabase qdb,AjPList qcas)3929 AjBool ensQcalignmentadaptorFetchAllbyQcdatabaseQuery(
3930 EnsPQcalignmentadaptor qcaa,
3931 const EnsPAnalysis analysis,
3932 const EnsPQcdatabase qdb,
3933 AjPList qcas)
3934 {
3935 AjBool result = AJFALSE;
3936
3937 AjPStr constraint = NULL;
3938
3939 if (!qcaa)
3940 return ajFalse;
3941
3942 if (!qdb)
3943 return ajFalse;
3944
3945 if (!qcas)
3946 return ajFalse;
3947
3948 constraint = ajFmtStr("alignment.query_db_id = %u",
3949 ensQcdatabaseGetIdentifier(qdb));
3950
3951 if (analysis)
3952 ajFmtPrintAppS(&constraint,
3953 " AND alignment.analysis_id = %u",
3954 ensAnalysisGetIdentifier(analysis));
3955
3956 result = ensBaseadaptorFetchAllbyConstraint(
3957 ensQcalignmentadaptorGetBaseadaptor(qcaa),
3958 constraint,
3959 (EnsPAssemblymapper) NULL,
3960 (EnsPSlice) NULL,
3961 qcas);
3962
3963 ajStrDel(&constraint);
3964
3965 return result;
3966 }
3967
3968
3969
3970
3971 /* @func ensQcalignmentadaptorFetchAllbyQcdatabaseTarget **********************
3972 **
3973 ** Fetch all Ensembl Quality Check Alignment objects by a
3974 ** Target Ensembl Quality Check Sequence.
3975 ** The caller is responsible for deleting the Ensembl Quality Check Alignment
3976 ** objects before deleting the AJAX List.
3977 **
3978 ** @param [u] qcaa [EnsPQcalignmentadaptor]
3979 ** Ensembl Quality Check Alignment Adaptor
3980 ** @param [rN] analysis [const EnsPAnalysis] Ensembl Analysis
3981 ** @param [r] tdb [const EnsPQcdatabase] Target Ensembl Quality Check Database
3982 ** @param [u] qcas [AjPList] AJAX List of
3983 ** Ensembl Quality Check Alignment objects
3984 **
3985 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3986 **
3987 ** @release 6.4.0
3988 ** @@
3989 ******************************************************************************/
3990
ensQcalignmentadaptorFetchAllbyQcdatabaseTarget(EnsPQcalignmentadaptor qcaa,const EnsPAnalysis analysis,const EnsPQcdatabase tdb,AjPList qcas)3991 AjBool ensQcalignmentadaptorFetchAllbyQcdatabaseTarget(
3992 EnsPQcalignmentadaptor qcaa,
3993 const EnsPAnalysis analysis,
3994 const EnsPQcdatabase tdb,
3995 AjPList qcas)
3996 {
3997 AjBool result = AJFALSE;
3998
3999 AjPStr constraint = NULL;
4000
4001 if (!qcaa)
4002 return ajFalse;
4003
4004 if (!tdb)
4005 return ajFalse;
4006
4007 if (!qcas)
4008 return ajFalse;
4009
4010 constraint = ajFmtStr("alignment.target_db_id = %u",
4011 ensQcdatabaseGetIdentifier(tdb));
4012
4013 if (analysis)
4014 ajFmtPrintAppS(&constraint,
4015 " AND alignment.analysis_id = %u",
4016 ensAnalysisGetIdentifier(analysis));
4017
4018 result = ensBaseadaptorFetchAllbyConstraint(
4019 ensQcalignmentadaptorGetBaseadaptor(qcaa),
4020 constraint,
4021 (EnsPAssemblymapper) NULL,
4022 (EnsPSlice) NULL,
4023 qcas);
4024
4025 ajStrDel(&constraint);
4026
4027 return result;
4028 }
4029
4030
4031
4032
4033 /* @func ensQcalignmentadaptorFetchByIdentifier *******************************
4034 **
4035 ** Fetch an Ensembl Quality Check Alignment via its
4036 ** SQL database-internal identifier.
4037 ** The caller is responsible for deleting the Ensembl Quality Check Alignment.
4038 **
4039 ** @param [u] qcaa [EnsPQcalignmentadaptor]
4040 ** Ensembl Quality Check Alignment Adaptor
4041 ** @param [r] identifier [ajuint] SQL database-internal
4042 ** Ensembl Quality Check Alignment identifier
4043 ** @param [wP] Pqca [EnsPQcalignment*] Ensembl Quality Check Alignment address
4044 **
4045 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4046 **
4047 ** @release 6.2.0
4048 ** @@
4049 ******************************************************************************/
4050
ensQcalignmentadaptorFetchByIdentifier(EnsPQcalignmentadaptor qcaa,ajuint identifier,EnsPQcalignment * Pqca)4051 AjBool ensQcalignmentadaptorFetchByIdentifier(EnsPQcalignmentadaptor qcaa,
4052 ajuint identifier,
4053 EnsPQcalignment *Pqca)
4054 {
4055 return ensBaseadaptorFetchByIdentifier(
4056 ensQcalignmentadaptorGetBaseadaptor(qcaa),
4057 identifier,
4058 (void **) Pqca);
4059 }
4060
4061
4062
4063
4064 /* @section object access *****************************************************
4065 **
4066 ** Functions for accessing Ensembl Quality Check Alignment objects in an
4067 ** Ensembl SQL database.
4068 **
4069 ** @fdata [EnsPQcalignmentadaptor]
4070 **
4071 ** @nam3rule Delete Delete Ensembl Quality Check Alignment object(s)
4072 ** @nam3rule Store Store Ensembl Quality Check Alignment object(s)
4073 ** @nam3rule Update Update Ensembl Quality Check Alignment object(s)
4074 **
4075 ** @argrule * qcaa [EnsPQcalignmentadaptor]
4076 ** Ensembl Quality Check Alignment Adaptor
4077 ** @argrule Delete qca [EnsPQcalignment] Ensembl Quality Check Alignment
4078 ** @argrule Store qca [EnsPQcalignment] Ensembl Quality Check Alignment
4079 ** @argrule Update qca [const EnsPQcalignment] Ensembl Quality Check Alignment
4080 **
4081 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
4082 **
4083 ** @fcategory use
4084 ******************************************************************************/
4085
4086
4087
4088
4089 /* @func ensQcalignmentadaptorDelete ******************************************
4090 **
4091 ** Delete an Ensembl Quality Check Alignment.
4092 **
4093 ** @param [u] qcaa [EnsPQcalignmentadaptor]
4094 ** Ensembl Quality Check Alignment Adaptor
4095 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
4096 **
4097 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4098 **
4099 ** @release 6.2.0
4100 ** @@
4101 ******************************************************************************/
4102
ensQcalignmentadaptorDelete(EnsPQcalignmentadaptor qcaa,EnsPQcalignment qca)4103 AjBool ensQcalignmentadaptorDelete(EnsPQcalignmentadaptor qcaa,
4104 EnsPQcalignment qca)
4105 {
4106 AjBool result = AJFALSE;
4107
4108 AjPSqlstatement sqls = NULL;
4109
4110 AjPStr statement = NULL;
4111
4112 EnsPDatabaseadaptor dba = NULL;
4113
4114 if (!qcaa)
4115 return ajFalse;
4116
4117 if (!qca)
4118 return ajFalse;
4119
4120 if (!ensQcalignmentGetIdentifier(qca))
4121 return ajFalse;
4122
4123 dba = ensQcalignmentadaptorGetDatabaseadaptor(qcaa);
4124
4125 statement = ajFmtStr(
4126 "DELETE FROM "
4127 "alignment "
4128 "WHERE "
4129 "alignment.alignment_id = %u",
4130 qca->Identifier);
4131
4132 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
4133
4134 if (ajSqlstatementGetAffectedrows(sqls))
4135 {
4136 qca->Adaptor = NULL;
4137 qca->Identifier = 0U;
4138
4139 result = ajTrue;
4140 }
4141
4142 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
4143
4144 ajStrDel(&statement);
4145
4146 return result;
4147 }
4148
4149
4150
4151
4152 /* @func ensQcalignmentadaptorStore *******************************************
4153 **
4154 ** Store an Ensembl Quality Check Alignment.
4155 **
4156 ** @param [u] qcaa [EnsPQcalignmentadaptor]
4157 ** Ensembl Quality Check Alignment Adaptor
4158 ** @param [u] qca [EnsPQcalignment] Ensembl Quality Check Alignment
4159 **
4160 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4161 **
4162 ** @release 6.2.0
4163 ** @@
4164 ******************************************************************************/
4165
ensQcalignmentadaptorStore(EnsPQcalignmentadaptor qcaa,EnsPQcalignment qca)4166 AjBool ensQcalignmentadaptorStore(EnsPQcalignmentadaptor qcaa,
4167 EnsPQcalignment qca)
4168 {
4169 char *txtvulgar = NULL;
4170
4171 AjBool result = AJFALSE;
4172
4173 AjPSqlstatement sqls = NULL;
4174
4175 AjPStr statement = NULL;
4176
4177 EnsPDatabaseadaptor dba = NULL;
4178
4179 if (!qcaa)
4180 return ajFalse;
4181
4182 if (!qca)
4183 return ajFalse;
4184
4185 if (ensQcalignmentGetAdaptor(qca) &&
4186 ensQcalignmentGetIdentifier(qca))
4187 return ajFalse;
4188
4189 dba = ensQcalignmentadaptorGetDatabaseadaptor(qcaa);
4190
4191 ensDatabaseadaptorEscapeC(dba, &txtvulgar, qca->Vulgar);
4192
4193 statement = ajFmtStr(
4194 "INSERT IGNORE INTO "
4195 "alignment "
4196 "SET "
4197 "alignment.analysis_id = %u, "
4198 "alignment.query_db_id = %u, "
4199 "alignment.query_id = %u, "
4200 "alignment.query_start = %u, "
4201 "alignment.query_end = %u, "
4202 "alignment.query_strand = %d, "
4203 "alignment.target_db_id = %u, "
4204 "alignment.target_id = %u, "
4205 "alignment.target_start = %u, "
4206 "alignment.target_end = %u, "
4207 "alignment.target_strand = %d, "
4208 "alignment.splice_strand = %d, "
4209 "alignment.score = %f, "
4210 "alignment.identity = %f, "
4211 "alignment.vulgar_line = '%s', "
4212 "alignment.coverage = %u",
4213 ensAnalysisGetIdentifier(qca->Analysis),
4214 ensQcsequenceGetQcdatabaseIdentifier(
4215 qca->QuerySequence),
4216 ensQcsequenceGetIdentifier(qca->QuerySequence),
4217 qca->QueryStart,
4218 qca->QueryEnd,
4219 qca->QueryStrand,
4220 ensQcsequenceGetQcdatabaseIdentifier(
4221 qca->TargetSequence),
4222 ensQcsequenceGetIdentifier(qca->TargetSequence),
4223 qca->TargetStart,
4224 qca->TargetEnd,
4225 qca->TargetStrand,
4226 qca->Splicestrand,
4227 qca->Score,
4228 qca->Identity,
4229 txtvulgar,
4230 qca->Coverage);
4231
4232 ajCharDel(&txtvulgar);
4233
4234 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
4235
4236 if (ajSqlstatementGetAffectedrows(sqls))
4237 {
4238 ensQcalignmentSetIdentifier(qca, ajSqlstatementGetIdentifier(sqls));
4239
4240 ensQcalignmentSetAdaptor(qca, qcaa);
4241
4242 result = ajTrue;
4243 }
4244
4245 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
4246
4247 ajStrDel(&statement);
4248
4249 return result;
4250 }
4251
4252
4253
4254
4255 /* @func ensQcalignmentadaptorUpdate ******************************************
4256 **
4257 ** Update an Ensembl Quality Check Alignment.
4258 **
4259 ** @param [u] qcaa [EnsPQcalignmentadaptor]
4260 ** Ensembl Quality Check Alignment Adaptor
4261 ** @param [r] qca [const EnsPQcalignment] Ensembl Quality Check Alignment
4262 **
4263 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4264 **
4265 ** @release 6.2.0
4266 ** @@
4267 ******************************************************************************/
4268
ensQcalignmentadaptorUpdate(EnsPQcalignmentadaptor qcaa,const EnsPQcalignment qca)4269 AjBool ensQcalignmentadaptorUpdate(EnsPQcalignmentadaptor qcaa,
4270 const EnsPQcalignment qca)
4271 {
4272 char *txtvulgar = NULL;
4273
4274 AjBool result = AJFALSE;
4275
4276 AjPSqlstatement sqls = NULL;
4277
4278 AjPStr statement = NULL;
4279
4280 EnsPDatabaseadaptor dba = NULL;
4281
4282 if (!qcaa)
4283 return ajFalse;
4284
4285 if (!qca)
4286 return ajFalse;
4287
4288 if (!ensQcalignmentGetIdentifier(qca))
4289 return ajFalse;
4290
4291 dba = ensQcalignmentadaptorGetDatabaseadaptor(qcaa);
4292
4293 ensDatabaseadaptorEscapeC(dba, &txtvulgar, qca->Vulgar);
4294
4295 statement = ajFmtStr(
4296 "UPDATE IGNORE "
4297 "alignment "
4298 "SET "
4299 "alignment.analysis_id = %u, "
4300 "alignment.query_db_id = %u, "
4301 "alignment.query_id = %u, "
4302 "alignment.query_start = %u, "
4303 "alignment.query_end = %u, "
4304 "alignment.query_strand = %d, "
4305 "alignment.target_db_id = %u, "
4306 "alignment.target_id = %u, "
4307 "alignment.target_start = %u, "
4308 "alignment.target_end = %u, "
4309 "alignment.target_strand = %d, "
4310 "alignment.splice_strand = %d, "
4311 "alignment.score = %f, "
4312 "alignment.identity = %f, "
4313 "alignment.vulgar_line = '%s', "
4314 "alignment.coverage = %u "
4315 "WHERE "
4316 "alignment.alignment_id = %u",
4317 ensAnalysisGetIdentifier(qca->Analysis),
4318 ensQcsequenceGetQcdatabaseIdentifier(
4319 qca->QuerySequence),
4320 ensQcsequenceGetIdentifier(qca->QuerySequence),
4321 qca->QueryStart,
4322 qca->QueryEnd,
4323 qca->QueryStrand,
4324 ensQcsequenceGetQcdatabaseIdentifier(
4325 qca->TargetSequence),
4326 ensQcsequenceGetIdentifier(qca->TargetSequence),
4327 qca->TargetStart,
4328 qca->TargetEnd,
4329 qca->TargetStrand,
4330 qca->Splicestrand,
4331 qca->Score,
4332 qca->Identity,
4333 txtvulgar,
4334 qca->Coverage,
4335 qca->Identifier);
4336
4337 ajCharDel(&txtvulgar);
4338
4339 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
4340
4341 if (ajSqlstatementGetAffectedrows(sqls))
4342 result = ajTrue;
4343
4344 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
4345
4346 ajStrDel(&statement);
4347
4348 return result;
4349 }
4350