rc_t CGWriterEvdInt_Write(const CGWriterEvdInt* cself, const TEvidenceDnbsData* dnbs, int64_t* rowid)
{
    rc_t rc = 0;
    CGWriterEvdInt* self = (CGWriterEvdInt*)cself;
    
    assert(cself != NULL);

    memset(self->data.allele_indexes_to_read_number, 0, sizeof(self->data.allele_indexes_to_read_number));
    if( self->data.ploidy == 1 ) {

        uint32_t i = self->data.allele_indexes[0] - '0';

        if( self->data.allele_indexes[1] != '\0' || i > 2 ) {
            rc = RC(rcExe, rcFormatter, rcWriting, rcData, rcOutofrange);
        } else if( self->data.allele_alignment_length[i] == 0 ) {
            rc = RC(rcExe, rcFormatter, rcWriting, rcData, rcEmpty);
        } else {
            if( i == 0 ) {
                rc = string_printf(self->data.allele_alignment[0], sizeof(self->data.allele_alignment[0]),
                                   &self->data.allele_alignment_length[0], "%uM", self->data.length);
            }
            if( rc == 0 ) {
                self->algn.ploidy = 0;
                rc = ReferenceMgr_Compress(cself->rmgr, ewrefmgr_cmp_Exact, self->data.chr, self->data.offset, self->data.allele[i], self->data.allele_length[i],
                                           self->data.allele_alignment[i], self->data.allele_alignment_length[i],
                                           0, NULL, 0, 0, NULL, 0, &self->algn);
                self->data.allele_indexes_to_read_number[i] = 1; /* 1st read */
            }
        }

    } else if( self->data.ploidy == 2 ) {  /** possibilities: 0;1 1;2 and 1;1 - single ploidy but recorded as dual **/
        uint32_t i1 = self->data.allele_indexes[0] - '0';
        uint32_t i2 = self->data.allele_indexes[2] - '0';

        if( self->data.allele_indexes[1] != ';' || self->data.allele_indexes[3] != '\0' || i1 > 2 || i2 > 2) {
            rc = RC(rcExe, rcFormatter, rcWriting, rcData, rcOutofrange);
        } else {
            if( i1 == 0 || i2 == 0 ) {
                rc = string_printf(self->data.allele_alignment[0], sizeof(self->data.allele_alignment[0]),
                                   &self->data.allele_alignment_length[0], "%uM", self->data.length);
            }
            if( self->data.allele_alignment_length[i1] == 0 || self->data.allele_alignment_length[i2] == 0 ) {
                rc = RC(rcExe, rcFormatter, rcWriting, rcData, rcEmpty);
            }
            if( rc == 0 ) {
                self->algn.ploidy = 0;
                rc = ReferenceMgr_Compress(cself->rmgr, ewrefmgr_cmp_Exact, self->data.chr, self->data.offset, self->data.allele[i1], self->data.allele_length[i1],
                                           self->data.allele_alignment[i1], self->data.allele_alignment_length[i1],
                                           0, NULL, 0, 0, NULL, 0, &self->algn);
                self->data.allele_indexes_to_read_number[i1] = 1; /* 1st read */
            }
            if( rc == 0 ) {
		if ( i2 != i1 ) {
			rc = ReferenceMgr_Compress(cself->rmgr, ewrefmgr_cmp_Exact, self->data.chr, self->data.offset, self->data.allele[i2], self->data.allele_length[i2],
                                           self->data.allele_alignment[i2], self->data.allele_alignment_length[i2],
                                           0, NULL, 0, 0, NULL, 0, &self->algn);
			self->data.allele_indexes_to_read_number[i2] = 2; /* 2nd read */
		} else {
			self->data.ploidy = 1;
		}
            }
        }

    }  else if( self->data.ploidy == 3 ) { /** possibilities: 0;1;2 1;2;3 **/
        uint32_t i1 = self->data.allele_indexes[0] - '0';
        uint32_t i2 = self->data.allele_indexes[2] - '0';
        uint32_t i3 = self->data.allele_indexes[4] - '0';


        if( self->data.allele_indexes[1] != ';'  || self->data.allele_indexes[3] != ';' || self->data.allele_indexes[5] != '\0' || i1 > 3 || i2 > 3 || i3 > 3) {
            rc = RC(rcExe, rcFormatter, rcWriting, rcData, rcOutofrange);
        } else {
            if( i1 == 0 || i2 == 0 || i3 == 0) {
                rc = string_printf(self->data.allele_alignment[0], sizeof(self->data.allele_alignment[0]),
                                   &self->data.allele_alignment_length[0], "%uM", self->data.length);
            }
            if( self->data.allele_alignment_length[i1] == 0 || self->data.allele_alignment_length[i2] == 0 || self->data.allele_alignment_length[i3]==0) {
                rc = RC(rcExe, rcFormatter, rcWriting, rcData, rcEmpty);
            }
            if( rc == 0 ) {
                self->algn.ploidy = 0;
                rc = ReferenceMgr_Compress(cself->rmgr, ewrefmgr_cmp_Exact, self->data.chr, self->data.offset, self->data.allele[i1], self->data.allele_length[i1],
                                           self->data.allele_alignment[i1], self->data.allele_alignment_length[i1],
                                           0, NULL, 0, 0, NULL, 0, &self->algn);
                self->data.allele_indexes_to_read_number[i1] = 1; /* 1st read */
            }
            if( rc == 0 ) {
                rc = ReferenceMgr_Compress(cself->rmgr, ewrefmgr_cmp_Exact, self->data.chr, self->data.offset, self->data.allele[i2], self->data.allele_length[i2],
                                           self->data.allele_alignment[i2], self->data.allele_alignment_length[i2],
                                           0, NULL, 0, 0, NULL, 0, &self->algn);
                self->data.allele_indexes_to_read_number[i2] = 2; /* 2nd read */
            }
            if( rc == 0 ) {
                rc = ReferenceMgr_Compress(cself->rmgr, ewrefmgr_cmp_Exact, self->data.chr, self->data.offset, self->data.allele[i3], self->data.allele_length[i3],
                                           self->data.allele_alignment[i3], self->data.allele_alignment_length[i3],
                                           0, NULL, 0, 0, NULL, 0, &self->algn);
                self->data.allele_indexes_to_read_number[i3] = 3; /* 3rd read */
            }
        }

    } else {
        rc = RC(rcExe, rcFormatter, rcWriting, rcData, rcUnrecognized);
    }
    if( rc == 0 ) { /*** a bit careful here - were are predicting what EvidenceDnb writer will do ***/
	uint32_t i,valid_qty;
	for(valid_qty = i = 0;i< dnbs->qty;i++){
		if(self->data.allele_indexes_to_read_number[dnbs->dnbs[i].allele_index] > 0){
			valid_qty++;
		}
	}
        if( self->dnbs_ids_max < valid_qty ) {
            void* p = realloc(self->dnbs_ids, sizeof(*(self->dnbs_ids)) * valid_qty);
            if( p == NULL ) {
                rc = RC(rcExe, rcFormatter, rcWriting, rcMemory, rcExhausted);
            } else {
                self->dnbs_ids = p;
                self->dnbs_ids_max = valid_qty;
                self->algn.alingment_ids.buffer = self->dnbs_ids;
            }
        }
        if( rc == 0 ) {
            self->algn.alingment_ids.elements = valid_qty;
	    for(i=0;i<valid_qty;i++){
		self->dnbs_ids[i] = dnbs->last_rowid + i;
            }
        }
    }
    if( rc == 0 ) {
        self->match.mapq = self->data.score;
        rc = TableWriterAlgn_Write(self->writer, &self->algn, rowid);
    }
    return rc;
}
Example #2
0
static
rc_t CGWriterAlgn_Save(CGWriterAlgn *const self,
                       TReadsData *const rd,
                       TableWriterAlgn const *const writer,
                       uint32_t const mate,
                       int64_t *const rowid)
{
    rc_t rc = 0;
    TMappingsData_map *const map = &self->data.map[mate];

    if( !map->saved ) {
        CGWriterAlgn_match *const match = &self->match[mate];
        TableWriterAlgnData *const algn = &self->algn[mate];

        uint32_t g = 0;

        uint32_t* cigar = NULL;
        uint32_t left_cigar15 []={  5 << 4, 0, 10 << 4, 0, 10 << 4, 0,10 << 4 };
        uint32_t right_cigar15[]={ 10 << 4, 0, 10 << 4, 0, 10 << 4, 0, 5 << 4 };
        uint32_t left_cigar25 []={ 10 << 4, 0, 10 << 4, 0, 10 << 4, 0, 0 };
        uint32_t right_cigar25[]={ 10 << 4, 0, 10 << 4, 0, 10 << 4, 0, 0 };
        uint32_t *left_cigar  = NULL;
        uint32_t *right_cigar = NULL;
        uint32_t cg_reads_ngaps = 0;

        const char *read = NULL;
        uint32_t read_len = 0;

        assert(rd);

        cg_reads_ngaps = get_cg_reads_ngaps(rd->reads_format);

        read_len = rd->seq.spot_len / 2;
        if (cg_reads_ngaps == 3) {
            left_cigar  = left_cigar15;
            right_cigar = right_cigar15;
        }
        else if (cg_reads_ngaps == 2) {
            left_cigar  = left_cigar25;
            right_cigar = right_cigar25;
        }
        else {
            assert(0);
        }

        if (match->seq_read_id == 2) {
            read = &((const char*)(rd->seq.sequence.buffer))[read_len];
            cigar = right_cigar;
            g = read_len;
        }
        else {
            read = rd->seq.sequence.buffer;
            cigar = left_cigar;
            g = 0;
        }
        if (match->ref_orientation) {
            if( rd->reverse[g] == '\0' ) {
                if( (rc = DNAReverseCompliment(read, &rd->reverse[g], read_len)) != 0) {
                    return rc;
                }
                DEBUG_MSG(10, ("'%.*s' -> cg_eRevDnbStrand: '%.*s'\n", read_len, read, read_len, &rd->reverse[g]));
            }
            read = &rd->reverse[g];
            cigar = (cigar == left_cigar) ? right_cigar : left_cigar;
        }
        for(g = 0; g < cg_reads_ngaps; g++) {
            if( map->gap[g] > 0 ) {
                cigar[g * 2 + 1] = (map->gap[g] << 4) | 3; /* 'xN' */
            } else if( map->gap[g] < 0 ) {
                cigar[g * 2 + 1] = (-map->gap[g] << 4) | 9; /* 'xB' */
            } else {
                cigar[g * 2 + 1] = 0; /* '0M' */
            }
        }
        algn->ploidy = 0;
        if( (rc = ReferenceMgr_Compress(self->rmgr, ewrefmgr_cmp_Binary,
                    map->chr, map->offset, read, read_len, cigar, 7, 0, NULL, 0, 0, NULL, 0, NCBI_align_ro_complete_genomics, algn)) != 0 ) {
            PLOGERR(klogErr, (klogErr, rc, "compression failed $(id) $(o)",
                    PLOG_2(PLOG_S(id),PLOG_I32(o)), map->chr, map->offset));
        }
        else {
#if 1
            /* this is to try represent these alignments as unmated to match cgatools
             * axf uses the row length of MATE_REF_ORIENTATION as the indicator of 
             * mate presence
             */
            unsigned const save = algn->mate_ref_orientation.elements;
            
            if (map->mate == mate)
                algn->mate_ref_orientation.elements = 0;
            
            rc = TableWriterAlgn_Write(writer, algn, rowid);
            
            if (map->mate == mate)
                algn->mate_ref_orientation.elements = save;
#else
            rc = TableWriterAlgn_Write(writer, algn, rowid);
#endif
            map->saved = true;
        }
    }

    return rc;
}