2014 lines
63 KiB
C++
2014 lines
63 KiB
C++
/*
|
||
* Copyright 2011, Ben Langmead <langmea@cs.jhu.edu>
|
||
*
|
||
* This file is part of Bowtie 2.
|
||
*
|
||
* Bowtie 2 is free software: you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation, either version 3 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* Bowtie 2 is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with Bowtie 2. If not, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#ifndef SAM_H_
|
||
#define SAM_H_
|
||
|
||
#include <string>
|
||
#include <sys/time.h>
|
||
#include "ds.h"
|
||
#include "read.h"
|
||
#include "util.h"
|
||
#include "aligner_result.h"
|
||
#include "scoring.h"
|
||
#include "alt.h"
|
||
#include "filebuf.h"
|
||
#include "alignment_3n.h"
|
||
|
||
enum {
|
||
// Comments use language from v1.4-r962 spec
|
||
SAM_FLAG_PAIRED = 1, // templ. having mult. frag.s in sequencing
|
||
SAM_FLAG_MAPPED_PAIRED = 2, // each frag properly aligned
|
||
SAM_FLAG_UNMAPPED = 4, // fragment unmapped
|
||
SAM_FLAG_MATE_UNMAPPED = 8, // next fragment in template unmapped
|
||
SAM_FLAG_QUERY_STRAND = 16, // SEQ is reverse comp'ed from original
|
||
SAM_FLAG_MATE_STRAND = 32, // next fragment SEQ reverse comp'ed
|
||
SAM_FLAG_FIRST_IN_PAIR = 64, // first fragment in template
|
||
SAM_FLAG_SECOND_IN_PAIR = 128, // last fragment in template
|
||
SAM_FLAG_NOT_PRIMARY = 256, // secondary alignment
|
||
SAM_FLAG_FAILS_CHECKS = 512, // not passing quality controls
|
||
SAM_FLAG_DUPLICATE = 1024 // PCR or optical duplicate
|
||
};
|
||
|
||
class AlnRes;
|
||
class AlnFlags;
|
||
class AlnSetSumm;
|
||
|
||
/**
|
||
* Encapsulates all the various ways that a user may wish to customize SAM
|
||
* output.
|
||
*/
|
||
template<typename index_t>
|
||
class SamConfig {
|
||
|
||
typedef EList<std::string> StrList;
|
||
typedef EList<size_t> LenList;
|
||
|
||
public:
|
||
|
||
SamConfig(
|
||
const StrList& refnames, // reference sequence names
|
||
const LenList& reflens, // reference sequence lengths
|
||
const StrList& repnames, // repeat sequence names
|
||
const LenList& replens, // repeat sequence lengths
|
||
bool truncQname, // truncate read name to 255?
|
||
bool omitsec, // omit secondary SEQ/QUAL
|
||
bool noUnal, // omit unaligned reads
|
||
const std::string& pg_id, // id
|
||
const std::string& pg_pn, // name
|
||
const std::string& pg_vn, // version
|
||
const std::string& pg_cl, // command-line
|
||
const std::string& rgs, // read groups string
|
||
int rna_strandness,
|
||
bool print_as,
|
||
bool print_xs,
|
||
bool print_xss,
|
||
bool print_yn,
|
||
bool print_xn,
|
||
bool print_cs,
|
||
bool print_cq,
|
||
bool print_x0,
|
||
bool print_x1,
|
||
bool print_xm,
|
||
bool print_xo,
|
||
bool print_xg,
|
||
bool print_nm,
|
||
bool print_md,
|
||
bool print_yf,
|
||
bool print_yi,
|
||
bool print_ym,
|
||
bool print_yp,
|
||
bool print_yt,
|
||
bool print_ys,
|
||
bool print_zs,
|
||
bool print_xr,
|
||
bool print_xt,
|
||
bool print_xd,
|
||
bool print_xu,
|
||
bool print_ye, // streak of failed DPs at end
|
||
bool print_yl, // longest streak of failed DPs
|
||
bool print_yu, // index of last succeeded DP
|
||
bool print_xp, // print seed hit information
|
||
bool print_yr, // # redundant seed hits
|
||
bool print_zb, // # Ftab lookups
|
||
bool print_zr, // # redundant path checks
|
||
bool print_zf, // # FM Index ops
|
||
bool print_zm, // FM Index op string for best-first search
|
||
bool print_zi, // # seed extend loop iters
|
||
bool print_zp,
|
||
bool print_zu,
|
||
bool print_xs_a,
|
||
bool print_nh) :
|
||
truncQname_(truncQname),
|
||
omitsec_(omitsec),
|
||
noUnal_(noUnal),
|
||
pg_id_(pg_id),
|
||
pg_pn_(pg_pn),
|
||
pg_vn_(pg_vn),
|
||
pg_cl_(pg_cl),
|
||
rgs_(rgs),
|
||
refnames_(refnames),
|
||
reflens_(reflens),
|
||
repnames_(repnames),
|
||
replens_(replens),
|
||
rna_strandness_(rna_strandness),
|
||
print_as_(print_as), // alignment score of best alignment
|
||
print_xs_(print_xs), // alignment score of second-best alignment
|
||
print_xss_(print_xss),
|
||
print_yn_(print_yn), // minimum valid score and perfect score
|
||
print_xn_(print_xn),
|
||
print_cs_(print_cs),
|
||
print_cq_(print_cq),
|
||
print_x0_(print_x0),
|
||
print_x1_(print_x1),
|
||
print_xm_(print_xm),
|
||
print_xo_(print_xo),
|
||
print_xg_(print_xg),
|
||
print_nm_(print_nm),
|
||
print_md_(print_md),
|
||
print_yf_(print_yf),
|
||
print_yi_(print_yi),
|
||
print_ym_(print_ym),
|
||
print_yp_(print_yp),
|
||
print_yt_(print_yt),
|
||
print_ys_(print_ys),
|
||
print_zs_(print_zs),
|
||
print_xr_(print_xr),
|
||
print_xt_(print_xt), // time elapsed in microseconds
|
||
print_xd_(print_xd), // DP extend attempts
|
||
print_xu_(print_xu), // ungapped extend attempts
|
||
print_ye_(print_ye), // streak of failed DPs at end
|
||
print_yl_(print_yl), // longest streak of failed DPs
|
||
print_yu_(print_yu), // index of last succeeded DP
|
||
print_xp_(print_xp), // print seed hit information
|
||
print_yr_(print_yr), // index of last succeeded DP
|
||
print_zb_(print_zb), // # Ftab lookups
|
||
print_zr_(print_zr), // # redundant path checks
|
||
print_zf_(print_zf), // # FM Index ops
|
||
print_zm_(print_zm), // FM Index op string for best-first search
|
||
print_zi_(print_zi), // # seed extend loop iters
|
||
print_zp_(print_zp), // # seed extend loop iters
|
||
print_zu_(print_zu), // # seed extend loop iters
|
||
print_xs_a_(print_xs_a),
|
||
print_nh_(print_nh)
|
||
{
|
||
assert_eq(refnames_.size(), reflens_.size());
|
||
}
|
||
|
||
/**
|
||
* Print a reference name in a way that doesn't violate SAM's character
|
||
* constraints. \*|[!-()+-<>-~][!-~]*
|
||
*/
|
||
void printRefName(
|
||
BTString& o,
|
||
const std::string& name)
|
||
const;
|
||
|
||
/**
|
||
* Print a :Z optional field where certain characters (whitespace, colon
|
||
* and percent) are escaped using % escapes.
|
||
*/
|
||
template<typename T>
|
||
void printOptFieldEscapedZ(BTString& o, const T& s) const {
|
||
size_t len = s.length();
|
||
for(size_t i = 0; i < len; i++) {
|
||
if(s[i] < 33 || s[i] > 126 || s[i] == ':' || s[i] == '%') {
|
||
// percent-encode it
|
||
o.append('%');
|
||
int ms = s[i] >> 4;
|
||
int ls = s[i] & 15;
|
||
assert_range(0, 15, ms);
|
||
assert_range(0, 15, ls);
|
||
o.append("0123456789ABCDEF"[ms]);
|
||
o.append("0123456789ABCDEF"[ls]);
|
||
} else {
|
||
o.append(s[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Print a :Z optional field where newline characters are escaped using %
|
||
* escapes.
|
||
*/
|
||
template<typename T>
|
||
void printOptFieldNewlineEscapedZ(BTString& o, const T& s) const {
|
||
size_t len = s.length();
|
||
for(size_t i = 0; i < len; i++) {
|
||
if(s[i] == 10 || s[i] == 13 || s[i] == '%') {
|
||
// percent-encode it
|
||
o.append('%');
|
||
int ms = s[i] >> 4;
|
||
int ls = s[i] & 15;
|
||
assert_range(0, 15, ms);
|
||
assert_range(0, 15, ls);
|
||
o.append("0123456789ABCDEF"[ms]);
|
||
o.append("0123456789ABCDEF"[ls]);
|
||
} else {
|
||
o.append(s[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Print a read name in a way that doesn't violate SAM's character
|
||
* constraints. [!-?A-~]{1,255} (i.e. [33, 63], [65, 126])
|
||
*/
|
||
template<typename TStr>
|
||
void printReadName(
|
||
BTString& o,
|
||
const TStr& name,
|
||
bool omitSlashMate)
|
||
const
|
||
{
|
||
size_t namelen = name.length();
|
||
if(omitSlashMate &&
|
||
namelen >= 2 &&
|
||
name[namelen-2] == '/' &&
|
||
(name[namelen-1] == '1' || name[namelen-1] == '2' || name[namelen-1] == '3'))
|
||
{
|
||
namelen -= 2;
|
||
}
|
||
if(truncQname_ && namelen > 255) {
|
||
namelen = 255;
|
||
}
|
||
for(size_t i = 0; i < namelen; i++) {
|
||
if(truncQname_ && isspace(name[i])) {
|
||
return;
|
||
}
|
||
o.append(name[i]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Print a reference name given a reference index.
|
||
*/
|
||
void printRefNameFromIndex(
|
||
BTString& o,
|
||
size_t i,
|
||
bool repeat = false)
|
||
const;
|
||
|
||
/**
|
||
* Print SAM header to given output buffer.
|
||
*/
|
||
void printHeader(
|
||
BTString& o,
|
||
const std::string& rgid,
|
||
const std::string& rgs,
|
||
bool printHd,
|
||
bool printSq,
|
||
bool printPg)
|
||
const;
|
||
|
||
/**
|
||
* Print the @HD header line to the given string.
|
||
*/
|
||
void printHdLine(BTString& o, const char *samver) const;
|
||
|
||
/**
|
||
* Print the @SQ header lines to the given string.
|
||
*/
|
||
void printSqLines(BTString& o) const;
|
||
|
||
/**
|
||
* Print the @PG header line to the given string.
|
||
*/
|
||
void printPgLine(BTString& o) const;
|
||
|
||
/**
|
||
* Print the optional flags to the given string.
|
||
*/
|
||
void printAlignedOptFlags(
|
||
BTString& o, // output buffer
|
||
bool first, // first opt flag printed is first overall?
|
||
const Read& rd, // the read
|
||
AlnRes& res, // individual alignment result
|
||
StackedAln& staln, // stacked alignment
|
||
const AlnFlags& flags, // alignment flags
|
||
const AlnSetSumm& summ, // summary of alignments for this read
|
||
const SeedAlSumm& ssm, // seed alignment summary
|
||
const PerReadMetrics& prm, // per-read metics
|
||
const Scoring& sc, // scoring scheme
|
||
const char *mapqInp, // inputs to MAPQ calculation
|
||
const ALTDB<index_t>* altdb)
|
||
const;
|
||
|
||
/**
|
||
* Print the optional flags to the given string.
|
||
*/
|
||
void printAlignedOptFlags(
|
||
Alignment* newAlignment, // output buffer
|
||
bool first, // first opt flag printed is first overall?
|
||
const Read& rd, // the read
|
||
AlnRes& res, // individual alignment result
|
||
StackedAln& staln, // stacked alignment
|
||
const AlnFlags& flags, // alignment flags
|
||
const AlnSetSumm& summ, // summary of alignments for this read
|
||
const SeedAlSumm& ssm, // seed alignment summary
|
||
const PerReadMetrics& prm, // per-read metics
|
||
const Scoring& sc, // scoring scheme
|
||
const char *mapqInp, // inputs to MAPQ calculation
|
||
const ALTDB<index_t>* altdb)
|
||
const;
|
||
/**
|
||
* Print the optional flags to the given string.
|
||
*/
|
||
void printEmptyOptFlags(
|
||
BTString& o, // output buffer
|
||
bool first, // first opt flag printed is first overall?
|
||
const Read& rd, // the read
|
||
const AlnFlags& flags, // alignment flags
|
||
const AlnSetSumm& summ, // summary of alignments for this read
|
||
const SeedAlSumm& ssm, // seed alignment summary
|
||
const PerReadMetrics& prm, // per-read metrics
|
||
const Scoring& sc) // scoring scheme
|
||
const;
|
||
|
||
void printEmptyOptFlags(
|
||
Alignment* newAlignment, // output buffer
|
||
bool first, // first opt flag printed is first overall?
|
||
const Read& rd, // the read
|
||
const AlnFlags& flags, // alignment flags
|
||
const AlnSetSumm& summ, // summary of alignments for this read
|
||
const SeedAlSumm& ssm, // seed alignment summary
|
||
const PerReadMetrics& prm, // per-read metrics
|
||
const Scoring& sc) // scoring scheme
|
||
const;
|
||
|
||
/**
|
||
* Return true iff we should try to obey the SAM spec's recommendations
|
||
* that:
|
||
*
|
||
* SEQ and QUAL of secondary alignments should be set to ‘*’ to reduce the
|
||
* file size.
|
||
*/
|
||
bool omitSecondarySeqQual() const {
|
||
return omitsec_;
|
||
}
|
||
|
||
bool omitUnalignedReads() const {
|
||
return noUnal_;
|
||
}
|
||
|
||
protected:
|
||
|
||
bool truncQname_; // truncate QNAME to 255 chars?
|
||
bool omitsec_; // omit secondary
|
||
bool noUnal_; // omit unaligned reads
|
||
|
||
std::string pg_id_; // @PG ID: Program record identifier
|
||
std::string pg_pn_; // @PG PN: Program name
|
||
std::string pg_vn_; // @PG VN: Program version
|
||
std::string pg_cl_; // @PG CL: Program command-line
|
||
std::string rgs_; // Read-group string to add to all records
|
||
const StrList& refnames_; // reference sequence names
|
||
const LenList& reflens_; // reference sequence lengths
|
||
|
||
const StrList& repnames_; // repeat sequence names
|
||
const LenList& replens_; // repeat sequence lengths
|
||
|
||
int rna_strandness_;
|
||
|
||
// Which alignment flags to print?
|
||
|
||
// Following are printed by BWA-SW
|
||
bool print_as_; // AS:i: Alignment score generated by aligner
|
||
bool print_xs_; // XS:i: Suboptimal alignment score
|
||
bool print_xss_;// Xs:i: Best invalid alignment score found
|
||
bool print_yn_; // YN:i:, Yn:i: minimum valid score and perfect score
|
||
bool print_xn_; // XN:i: Number of ambiguous bases in the referenece
|
||
|
||
// Other optional flags
|
||
bool print_cs_; // CS:Z: Color read sequence on the original strand
|
||
bool print_cq_; // CQ:Z: Color read quality on the original strand
|
||
|
||
// Following are printed by BWA
|
||
bool print_x0_; // X0:i: Number of best hits
|
||
bool print_x1_; // X1:i: Number of sub-optimal best hits
|
||
bool print_xm_; // XM:i: Number of mismatches in the alignment
|
||
bool print_xo_; // XO:i: Number of gap opens
|
||
bool print_xg_; // XG:i: Number of gap extensions (incl. opens)
|
||
bool print_nm_; // NM:i: Edit dist. to the ref, Ns count, clipping doesn't
|
||
bool print_md_; // MD:Z: String for mms. [0-9]+(([A-Z]|\^[A-Z]+)[0-9]+)*2
|
||
|
||
// Following are Bowtie2-specific
|
||
bool print_yf_; // YF:i: Read was filtered out?
|
||
bool print_yi_; // YI:Z: Summary of inputs to MAPQ calculation
|
||
bool print_ym_; // YM:i: Read was repetitive when aligned unpaired?
|
||
bool print_yp_; // YP:i: Read was repetitive when aligned paired?
|
||
bool print_yt_; // YT:Z: String representing alignment type
|
||
bool print_ys_; // YS:i: Score of other mate
|
||
bool print_zs_; // ZS:i: Pseudo-random seed
|
||
|
||
bool print_xr_; // XR:Z: Original read string
|
||
bool print_xt_; // XT:i: Time taken to align
|
||
bool print_xd_; // XD:i: DP problems
|
||
bool print_xu_; // XU:i: ungapped alignment
|
||
bool print_ye_; // YE:i: streak of failed DPs at end
|
||
bool print_yl_; // YL:i: longest streak of failed DPs
|
||
bool print_yu_; // YU:i: index of last succeeded DP
|
||
bool print_xp_; // XP:BI: seed hit information
|
||
bool print_yr_; // YR:i: # redundant seed hits
|
||
bool print_zb_; // ZB:i: # Ftab lookups
|
||
bool print_zr_; // ZR:i: # redundant path checks
|
||
bool print_zf_; // ZF:i: # FM Index ops
|
||
bool print_zm_; // ZM:i: FM ops string for best-first search
|
||
bool print_zi_; // ZI:i: # extend loop iters
|
||
bool print_zp_; // ZP:i: Score of best/second-best paired-end alignment
|
||
bool print_zu_; // ZU:i: Score of best/second-best unpaired alignment
|
||
|
||
bool print_xs_a_; // XS:A:[+=] Sense/anti-sense strand splice sites correspond to
|
||
bool print_nh_; // NH:i: # alignments
|
||
};
|
||
|
||
/**
|
||
* Print a reference name in a way that doesn't violate SAM's character
|
||
* constraints. \*|[!-()+-<>-~][!-~]* (i.e. [33, 63], [65, 126])
|
||
*/
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printRefName(
|
||
BTString& o,
|
||
const std::string& name) const
|
||
{
|
||
size_t namelen = name.length();
|
||
for(size_t i = 0; i < namelen; i++) {
|
||
if(isspace(name[i])) {
|
||
return;
|
||
}
|
||
o.append(name[i]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Print a reference name given a reference index.
|
||
*/
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printRefNameFromIndex(BTString& o, size_t i, bool repeat) const {
|
||
if(repeat) {
|
||
printRefName(o, repnames_[i]);
|
||
} else {
|
||
printRefName(o, refnames_[i]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Print SAM header to given output buffer.
|
||
*/
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printHeader(
|
||
BTString& o,
|
||
const string& rgid,
|
||
const string& rgs,
|
||
bool printHd,
|
||
bool printSq,
|
||
bool printPg) const
|
||
{
|
||
if(printHd) printHdLine(o, "1.0");
|
||
if(printSq) printSqLines(o);
|
||
if(!rgid.empty()) {
|
||
o.append("@RG");
|
||
o.append(rgid.c_str());
|
||
o.append(rgs.c_str());
|
||
o.append('\n');
|
||
}
|
||
if(printPg) printPgLine(o);
|
||
}
|
||
|
||
/**
|
||
* Print the @HD header line to the given string.
|
||
*/
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printHdLine(BTString& o, const char *samver) const {
|
||
o.append("@HD\tVN:");
|
||
o.append(samver);
|
||
o.append("\tSO:unsorted\n");
|
||
}
|
||
|
||
/**
|
||
* Print the @SQ header lines to the given string.
|
||
*/
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printSqLines(BTString& o) const {
|
||
char buf[1024];
|
||
for(size_t i = 0; i < refnames_.size(); i++) {
|
||
o.append("@SQ\tSN:");
|
||
printRefName(o, refnames_[i]);
|
||
o.append("\tLN:");
|
||
itoa10<size_t>(reflens_[i], buf);
|
||
o.append(buf);
|
||
o.append('\n');
|
||
}
|
||
if (!threeN) {
|
||
for(size_t i = 0; i < repnames_.size(); i++) {
|
||
o.append("@SQ\tSN:");
|
||
printRefName(o, repnames_[i]);
|
||
o.append("\tLN:");
|
||
itoa10<size_t>(replens_[i], buf);
|
||
o.append(buf);
|
||
o.append('\n');
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Print the @PG header line to the given string.
|
||
*/
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printPgLine(BTString& o) const {
|
||
o.append("@PG\tID:");
|
||
o.append(pg_id_.c_str());
|
||
o.append("\tPN:");
|
||
o.append(pg_pn_.c_str());
|
||
o.append("\tVN:");
|
||
o.append(pg_vn_.c_str());
|
||
o.append("\tCL:\"");
|
||
o.append(pg_cl_.c_str());
|
||
o.append('"');
|
||
o.append('\n');
|
||
}
|
||
|
||
#define WRITE_SEP() { \
|
||
if(!first) o.append('\t'); \
|
||
first = false; \
|
||
}
|
||
|
||
/**
|
||
* Print the optional flags to the given string.
|
||
*/
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printAlignedOptFlags(
|
||
BTString& o, // output buffer
|
||
bool first, // first opt flag printed is first overall?
|
||
const Read& rd, // the read
|
||
AlnRes& res, // individual alignment result
|
||
StackedAln& staln, // stacked alignment buffer
|
||
const AlnFlags& flags, // alignment flags
|
||
const AlnSetSumm& summ, // summary of alignments for this read
|
||
const SeedAlSumm& ssm, // seed alignment summary
|
||
const PerReadMetrics& prm, // per-read metrics
|
||
const Scoring& sc, // scoring scheme
|
||
const char *mapqInp, // inputs to MAPQ calculation
|
||
const ALTDB<index_t>* altdb)
|
||
const
|
||
{
|
||
char buf[1024];
|
||
if(print_as_) {
|
||
// AS:i: Alignment score generated by aligner
|
||
itoa10<TAlScore>(res.score().score(), buf);
|
||
WRITE_SEP();
|
||
o.append("AS:i:");
|
||
o.append(buf);
|
||
}
|
||
|
||
// Do not output suboptimal alignment score, which conflicts with Cufflinks and StringTie
|
||
if(print_xs_) {
|
||
// XS:i: Suboptimal alignment score
|
||
// Use ZS:i: to avoid conflict with XS:A:
|
||
AlnScore sco = summ.secbestMate(rd.mate < 2);
|
||
if(sco.valid()) {
|
||
itoa10<TAlScore>(sco.score(), buf);
|
||
WRITE_SEP();
|
||
o.append("ZS:i:");
|
||
o.append(buf);
|
||
}
|
||
}
|
||
if(print_xn_) {
|
||
// XN:i: Number of ambiguous bases in the referenece
|
||
itoa10<size_t>(res.refNs(), buf);
|
||
WRITE_SEP();
|
||
o.append("XN:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_x0_) {
|
||
// X0:i: Number of best hits
|
||
}
|
||
if(print_x1_) {
|
||
// X1:i: Number of sub-optimal best hits
|
||
}
|
||
size_t num_mm = 0;
|
||
size_t num_go = 0;
|
||
size_t num_gx = 0;
|
||
for(size_t i = 0; i < res.ned().size(); i++) {
|
||
if(res.ned()[i].isMismatch()) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_mm++;
|
||
}
|
||
} else if(res.ned()[i].isReadGap()) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_go++;
|
||
num_gx++;
|
||
}
|
||
while(i < res.ned().size()-1 &&
|
||
res.ned()[i+1].pos == res.ned()[i].pos &&
|
||
res.ned()[i+1].isReadGap())
|
||
{
|
||
i++;
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_gx++;
|
||
}
|
||
}
|
||
} else if(res.ned()[i].isRefGap()) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_go++;
|
||
num_gx++;
|
||
}
|
||
while(i < res.ned().size()-1 &&
|
||
res.ned()[i+1].pos == res.ned()[i].pos+1 &&
|
||
res.ned()[i+1].isRefGap())
|
||
{
|
||
i++;
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_gx++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if(print_xm_) {
|
||
// XM:i: Number of mismatches in the alignment
|
||
itoa10<size_t>(num_mm, buf);
|
||
WRITE_SEP();
|
||
o.append("XM:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xo_) {
|
||
// XO:i: Number of gap opens
|
||
itoa10<size_t>(num_go, buf);
|
||
WRITE_SEP();
|
||
o.append("XO:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xg_) {
|
||
// XG:i: Number of gap extensions (incl. opens)
|
||
itoa10<size_t>(num_gx, buf);
|
||
WRITE_SEP();
|
||
o.append("XG:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_nm_) {
|
||
// NM:i: Edit dist. to the ref, Ns count, clipping doesn't
|
||
size_t NM = 0;
|
||
for(size_t i = 0; i < res.ned().size(); i++) {
|
||
if(res.ned()[i].type != EDIT_TYPE_SPL) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
NM++;
|
||
}
|
||
}
|
||
}
|
||
itoa10<size_t>(NM, buf);
|
||
WRITE_SEP();
|
||
o.append("NM:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_md_) {
|
||
// MD:Z: String for mms. [0-9]+(([A-Z]|\^[A-Z]+)[0-9]+)*2
|
||
WRITE_SEP();
|
||
o.append("MD:Z:");
|
||
staln.buildMdz();
|
||
staln.writeMdz(
|
||
&o, // output buffer
|
||
NULL); // no char buffer
|
||
}
|
||
if(print_ys_ && summ.paired()) {
|
||
// YS:i: Alignment score of opposite mate
|
||
assert(res.oscore().valid());
|
||
itoa10<TAlScore>(res.oscore().score(), buf);
|
||
WRITE_SEP();
|
||
o.append("YS:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yn_) {
|
||
// YN:i: Minimum valid score for this mate
|
||
TAlScore mn = sc.scoreMin.f<TAlScore>(rd.length());
|
||
itoa10<TAlScore>(mn, buf);
|
||
WRITE_SEP();
|
||
o.append("YN:i:");
|
||
o.append(buf);
|
||
// Yn:i: Perfect score for this mate
|
||
TAlScore pe = sc.perfectScore(rd.length());
|
||
itoa10<TAlScore>(pe, buf);
|
||
WRITE_SEP();
|
||
o.append("Yn:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xss_) {
|
||
// Xs:i: Best invalid alignment score of this mate
|
||
bool one = true;
|
||
if(flags.partOfPair() && !flags.readMate1()) {
|
||
one = false;
|
||
}
|
||
TAlScore bst = one ? prm.bestLtMinscMate1 : prm.bestLtMinscMate2;
|
||
if(bst > std::numeric_limits<TAlScore>::min()) {
|
||
itoa10<TAlScore>(bst, buf);
|
||
WRITE_SEP();
|
||
o.append("Xs:i:");
|
||
o.append(buf);
|
||
}
|
||
if(flags.partOfPair()) {
|
||
// Ys:i: Best invalid alignment score of opposite mate
|
||
bst = one ? prm.bestLtMinscMate2 : prm.bestLtMinscMate1;
|
||
if(bst > std::numeric_limits<TAlScore>::min()) {
|
||
itoa10<TAlScore>(bst, buf);
|
||
WRITE_SEP();
|
||
o.append("Ys:i:");
|
||
o.append(buf);
|
||
}
|
||
}
|
||
}
|
||
if(print_zs_) {
|
||
// ZS:i: Pseudo-random seed for read
|
||
itoa10<uint32_t>(rd.seed, buf);
|
||
WRITE_SEP();
|
||
o.append("ZS:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yt_) {
|
||
// YT:Z: String representing alignment type
|
||
WRITE_SEP();
|
||
flags.printYT(o);
|
||
}
|
||
if(print_yp_ && flags.partOfPair() && flags.canMax()) {
|
||
// YP:i: Read was repetitive when aligned paired?
|
||
WRITE_SEP();
|
||
flags.printYP(o);
|
||
}
|
||
if(print_ym_ && flags.canMax() && (flags.isMixedMode() || !flags.partOfPair())) {
|
||
// YM:i: Read was repetitive when aligned unpaired?
|
||
WRITE_SEP();
|
||
flags.printYM(o);
|
||
}
|
||
if(print_yf_ && flags.filtered()) {
|
||
// YF:i: Read was filtered?
|
||
first = flags.printYF(o, first) && first;
|
||
}
|
||
if(print_yi_) {
|
||
// Print MAPQ calibration info
|
||
if(mapqInp[0] != '\0') {
|
||
// YI:i: Suboptimal alignment score
|
||
WRITE_SEP();
|
||
o.append("YI:Z:");
|
||
o.append(mapqInp);
|
||
}
|
||
}
|
||
if(flags.partOfPair() && print_zp_) {
|
||
// ZP:i: Score of best concordant paired-end alignment
|
||
WRITE_SEP();
|
||
o.append("ZP:Z:");
|
||
if(summ.bestPaired().valid()) {
|
||
itoa10<TAlScore>(summ.bestPaired().score(), buf);
|
||
o.append(buf);
|
||
} else {
|
||
o.append("NA");
|
||
}
|
||
// Zp:i: Second-best concordant paired-end alignment score
|
||
WRITE_SEP();
|
||
o.append("Zp:Z:");
|
||
if(summ.secbestPaired().valid()) {
|
||
itoa10<TAlScore>(summ.secbestPaired().score(), buf);
|
||
o.append(buf);
|
||
} else {
|
||
o.append("NA");
|
||
}
|
||
}
|
||
if(print_zu_) {
|
||
// ZU:i: Score of best unpaired alignment
|
||
AlnScore best = (rd.mate <= 1 ? summ.best1() : summ.best2());
|
||
AlnScore secbest = (rd.mate <= 1 ? summ.secbest1() : summ.secbest2());
|
||
WRITE_SEP();
|
||
o.append("ZU:i:");
|
||
if(best.valid()) {
|
||
itoa10<TAlScore>(best.score(), buf);
|
||
o.append(buf);
|
||
} else {
|
||
o.append("NA");
|
||
}
|
||
// Zu:i: Score of second-best unpaired alignment
|
||
WRITE_SEP();
|
||
o.append("Zu:i:");
|
||
if(secbest.valid()) {
|
||
itoa10<TAlScore>(secbest.score(), buf);
|
||
o.append(buf);
|
||
} else {
|
||
o.append("NA");
|
||
}
|
||
}
|
||
if(!rgs_.empty()) {
|
||
WRITE_SEP();
|
||
o.append(rgs_.c_str());
|
||
}
|
||
if(print_xt_) {
|
||
// XT:i: Timing
|
||
WRITE_SEP();
|
||
struct timeval tv_end;
|
||
struct timezone tz_end;
|
||
gettimeofday(&tv_end, &tz_end);
|
||
size_t total_usecs =
|
||
(tv_end.tv_sec - prm.tv_beg.tv_sec) * 1000000 +
|
||
(tv_end.tv_usec - prm.tv_beg.tv_usec);
|
||
itoa10<size_t>(total_usecs, buf);
|
||
o.append("XT:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xd_) {
|
||
// XD:i: Extend DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExDps, buf);
|
||
o.append("XD:i:");
|
||
o.append(buf);
|
||
// Xd:i: Mate DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nMateDps, buf);
|
||
o.append("Xd:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xu_) {
|
||
// XU:i: Extend ungapped tries
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExUgs, buf);
|
||
o.append("XU:i:");
|
||
o.append(buf);
|
||
// Xu:i: Mate ungapped tries
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nMateUgs, buf);
|
||
o.append("Xu:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_ye_) {
|
||
// YE:i: Streak of failed DPs at end
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpFail, buf);
|
||
o.append("YE:i:");
|
||
o.append(buf);
|
||
// Ye:i: Streak of failed ungaps at end
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgFail, buf);
|
||
o.append("Ye:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yl_) {
|
||
// YL:i: Longest streak of failed DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpFailStreak, buf);
|
||
o.append("YL:i:");
|
||
o.append(buf);
|
||
// Yl:i: Longest streak of failed ungaps
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgFailStreak, buf);
|
||
o.append("Yl:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yu_) {
|
||
// YU:i: Index of last succesful DP
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpLastSucc, buf);
|
||
o.append("YU:i:");
|
||
o.append(buf);
|
||
// Yu:i: Index of last succesful DP
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgLastSucc, buf);
|
||
o.append("Yu:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xp_) {
|
||
// XP:Z: String describing seed hits
|
||
WRITE_SEP();
|
||
o.append("XP:B:I,");
|
||
itoa10<uint64_t>(prm.nSeedElts, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nSeedEltsFw, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nSeedEltsRc, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.seedMean, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.seedMedian, buf);
|
||
o.append(buf);
|
||
}
|
||
if(print_yr_) {
|
||
// YR:i: Redundant seed hits
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nRedundants, buf);
|
||
o.append("YR:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zb_) {
|
||
// ZB:i: Ftab ops for seed alignment
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nFtabs, buf);
|
||
o.append("ZB:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zr_) {
|
||
// ZR:Z: Redundant path skips in seed alignment
|
||
WRITE_SEP();
|
||
o.append("ZR:Z:");
|
||
itoa10<uint64_t>(prm.nRedSkip, buf); o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nRedFail, buf); o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nRedIns, buf); o.append(buf);
|
||
}
|
||
if(print_zf_) {
|
||
// ZF:i: FM Index ops for seed alignment
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nSdFmops, buf);
|
||
o.append("ZF:i:");
|
||
o.append(buf);
|
||
// Zf:i: FM Index ops for offset resolution
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExFmops, buf);
|
||
o.append("Zf:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zm_) {
|
||
// ZM:Z: Print FM index op string for best-first search
|
||
WRITE_SEP();
|
||
o.append("ZM:Z:");
|
||
prm.fmString.print(o, buf);
|
||
}
|
||
if(print_zi_) {
|
||
// ZI:i: Seed extend loop iterations
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExIters, buf);
|
||
o.append("ZI:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xs_a_) {
|
||
if(rna_strandness_ == RNA_STRANDNESS_UNKNOWN) {
|
||
uint8_t whichsense = res.spliced_whichsense_transcript();
|
||
if(whichsense != SPL_UNKNOWN) {
|
||
WRITE_SEP();
|
||
o.append("XS:A:");
|
||
if(whichsense == SPL_FW || whichsense == SPL_SEMI_FW) {
|
||
o.append('+');
|
||
} else {
|
||
assert(whichsense == SPL_RC || whichsense == SPL_SEMI_RC);
|
||
o.append('-');
|
||
}
|
||
}
|
||
} else {
|
||
WRITE_SEP();
|
||
o.append("XS:A:");
|
||
char strandness = '+';
|
||
if(res.readMate1()) {
|
||
if(res.orient()) {
|
||
if(rna_strandness_ == RNA_STRANDNESS_R || rna_strandness_ == RNA_STRANDNESS_RF) {
|
||
strandness = '-';
|
||
}
|
||
} else {
|
||
if(rna_strandness_ == RNA_STRANDNESS_F || rna_strandness_ == RNA_STRANDNESS_FR) {
|
||
strandness = '-';
|
||
}
|
||
}
|
||
} else {
|
||
assert(res.readMate2());
|
||
assert(rna_strandness_ == RNA_STRANDNESS_FR || rna_strandness_ == RNA_STRANDNESS_RF);
|
||
if(res.orient()) {
|
||
if(rna_strandness_ == RNA_STRANDNESS_FR) {
|
||
strandness = '-';
|
||
}
|
||
} else {
|
||
if(rna_strandness_ == RNA_STRANDNESS_RF) {
|
||
strandness = '-';
|
||
}
|
||
}
|
||
}
|
||
o.append(strandness);
|
||
}
|
||
}
|
||
if(print_nh_) {
|
||
if(flags.alignedPaired()) {
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(summ.numAlnsPaired(), buf);
|
||
o.append("NH:i:");
|
||
o.append(buf);
|
||
} else if(flags.alignedUnpaired() || flags.alignedUnpairedMate()) {
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>((flags.alignedUnpaired() || flags.readMate1()) ?
|
||
summ.numAlns1() : summ.numAlns2(), buf);
|
||
o.append("NH:i:");
|
||
o.append(buf);
|
||
}
|
||
}
|
||
|
||
bool snp_first = true;
|
||
index_t prev_snp_idx = INDEX_MAX;
|
||
size_t len_trimmed = rd.length() - res.trimmed5p(true) - res.trimmed3p(true);
|
||
if(!res.fw()) {
|
||
Edit::invertPoss(const_cast<EList<Edit>&>(res.ned()), len_trimmed, false);
|
||
}
|
||
for(size_t i = 0; i < res.ned().size(); i++) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size())
|
||
continue;
|
||
index_t snp_idx = res.ned()[i].snpID;
|
||
assert_lt(snp_idx, altdb->alts().size());
|
||
const ALT<index_t>& snp = altdb->alts()[snp_idx];
|
||
const string& snpID = altdb->altnames()[snp_idx];
|
||
if(snp_idx == prev_snp_idx) continue;
|
||
if(snp_first) {
|
||
WRITE_SEP();
|
||
o.append("Zs:Z:");
|
||
}
|
||
if(!snp_first) o.append(",");
|
||
uint64_t pos = res.ned()[i].pos;
|
||
size_t j = i;
|
||
while(j > 0) {
|
||
if(res.ned()[j-1].snpID < altdb->alts().size()) {
|
||
const ALT<index_t>& snp2 = altdb->alts()[res.ned()[j-1].snpID];
|
||
if(snp2.type == ALT_SNP_SGL) {
|
||
pos -= (res.ned()[j-1].pos + 1);
|
||
} else if(snp2.type == ALT_SNP_DEL) {
|
||
pos -= res.ned()[j-1].pos;
|
||
} else if(snp2.type == ALT_SNP_INS) {
|
||
pos -= (res.ned()[j-1].pos + snp.len);
|
||
}
|
||
break;
|
||
}
|
||
j--;
|
||
}
|
||
itoa10<uint64_t>(pos, buf);
|
||
o.append(buf);
|
||
o.append("|");
|
||
if(snp.type == ALT_SNP_SGL) {
|
||
o.append("S");
|
||
} else if(snp.type == ALT_SNP_DEL) {
|
||
o.append("D");
|
||
} else {
|
||
assert_eq(snp.type, ALT_SNP_INS);
|
||
o.append("I");
|
||
}
|
||
o.append("|");
|
||
o.append(snpID.c_str());
|
||
|
||
if(snp_first) snp_first = false;
|
||
prev_snp_idx = snp_idx;
|
||
}
|
||
if(!res.fw()) {
|
||
Edit::invertPoss(const_cast<EList<Edit>&>(res.ned()), len_trimmed, false);
|
||
}
|
||
|
||
if(print_xr_) {
|
||
// Original read string
|
||
o.append("\n");
|
||
printOptFieldNewlineEscapedZ(o, rd.readOrigBuf);
|
||
}
|
||
}
|
||
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printAlignedOptFlags(
|
||
Alignment* newAlignment, // output buffer
|
||
bool first, // first opt flag printed is first overall?
|
||
const Read& rd, // the read
|
||
AlnRes& res, // individual alignment result
|
||
StackedAln& staln, // stacked alignment buffer
|
||
const AlnFlags& flags, // alignment flags
|
||
const AlnSetSumm& summ, // summary of alignments for this read
|
||
const SeedAlSumm& ssm, // seed alignment summary
|
||
const PerReadMetrics& prm, // per-read metrics
|
||
const Scoring& sc, // scoring scheme
|
||
const char *mapqInp, // inputs to MAPQ calculation
|
||
const ALTDB<index_t>* altdb)
|
||
const
|
||
{
|
||
BTString &o = newAlignment->unChangedTags;
|
||
char buf[1024];
|
||
if(print_as_) {
|
||
// AS:i: Alignment score generated by aligner
|
||
//itoa10<TAlScore>(res.score().score(), buf);
|
||
newAlignment->AS = res.score().score();
|
||
}
|
||
|
||
// Do not output suboptimal alignment score, which conflicts with Cufflinks and StringTie
|
||
if(print_xs_) {
|
||
// XS:i: Suboptimal alignment score
|
||
// Use ZS:i: to avoid conflict with XS:A:
|
||
AlnScore sco = summ.secbestMate(rd.mate < 2);
|
||
if(sco.valid()) {
|
||
itoa10<TAlScore>(sco.score(), buf);
|
||
WRITE_SEP();
|
||
o.append("ZS:i:");
|
||
o.append(buf);
|
||
}
|
||
}
|
||
if(print_xn_) {
|
||
// XN:i: Number of ambiguous bases in the referenece
|
||
itoa10<size_t>(res.refNs(), buf);
|
||
WRITE_SEP();
|
||
o.append("XN:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_x0_) {
|
||
// X0:i: Number of best hits
|
||
}
|
||
if(print_x1_) {
|
||
// X1:i: Number of sub-optimal best hits
|
||
}
|
||
size_t num_mm = 0;
|
||
size_t num_go = 0;
|
||
size_t num_gx = 0;
|
||
for(size_t i = 0; i < res.ned().size(); i++) {
|
||
if(res.ned()[i].isMismatch()) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_mm++;
|
||
}
|
||
} else if(res.ned()[i].isReadGap()) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_go++;
|
||
num_gx++;
|
||
}
|
||
while(i < res.ned().size()-1 &&
|
||
res.ned()[i+1].pos == res.ned()[i].pos &&
|
||
res.ned()[i+1].isReadGap())
|
||
{
|
||
i++;
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_gx++;
|
||
}
|
||
}
|
||
} else if(res.ned()[i].isRefGap()) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_go++;
|
||
num_gx++;
|
||
}
|
||
while(i < res.ned().size()-1 &&
|
||
res.ned()[i+1].pos == res.ned()[i].pos+1 &&
|
||
res.ned()[i+1].isRefGap())
|
||
{
|
||
i++;
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
num_gx++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if(print_xm_) {
|
||
// XM:i: Number of mismatches in the alignment
|
||
//itoa10<size_t>(num_mm, buf);
|
||
/*WRITE_SEP();
|
||
o.append("XM:i:");
|
||
o.append(buf);*/
|
||
newAlignment->XM = num_mm;
|
||
}
|
||
if(print_xo_) {
|
||
// XO:i: Number of gap opens
|
||
itoa10<size_t>(num_go, buf);
|
||
WRITE_SEP();
|
||
o.append("XO:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xg_) {
|
||
// XG:i: Number of gap extensions (incl. opens)
|
||
itoa10<size_t>(num_gx, buf);
|
||
WRITE_SEP();
|
||
o.append("XG:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_nm_) {
|
||
// NM:i: Edit dist. to the ref, Ns count, clipping doesn't
|
||
size_t NM = 0;
|
||
for(size_t i = 0; i < res.ned().size(); i++) {
|
||
if(res.ned()[i].type != EDIT_TYPE_SPL) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size()) {
|
||
NM++;
|
||
}
|
||
}
|
||
}
|
||
newAlignment->NM = NM;
|
||
}
|
||
if(print_md_) {
|
||
// MD:Z: String for mms. [0-9]+(([A-Z]|\^[A-Z]+)[0-9]+)*2
|
||
/*WRITE_SEP();
|
||
o.append("MD:Z:");*/
|
||
staln.buildMdz();
|
||
staln.writeMdz(
|
||
&newAlignment->MD, // output buffer
|
||
NULL); // no char buffer
|
||
}
|
||
if(print_ys_ && summ.paired()) {
|
||
// YS:i: Alignment score of opposite mate
|
||
assert(res.oscore().valid());
|
||
newAlignment->YS = res.oscore().score();
|
||
}
|
||
if(print_yn_) {
|
||
// YN:i: Minimum valid score for this mate
|
||
TAlScore mn = sc.scoreMin.f<TAlScore>(rd.length());
|
||
itoa10<TAlScore>(mn, buf);
|
||
WRITE_SEP();
|
||
o.append("YN:i:");
|
||
o.append(buf);
|
||
// Yn:i: Perfect score for this mate
|
||
TAlScore pe = sc.perfectScore(rd.length());
|
||
itoa10<TAlScore>(pe, buf);
|
||
WRITE_SEP();
|
||
o.append("Yn:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xss_) {
|
||
// Xs:i: Best invalid alignment score of this mate
|
||
bool one = true;
|
||
if(flags.partOfPair() && !flags.readMate1()) {
|
||
one = false;
|
||
}
|
||
TAlScore bst = one ? prm.bestLtMinscMate1 : prm.bestLtMinscMate2;
|
||
if(bst > std::numeric_limits<TAlScore>::min()) {
|
||
itoa10<TAlScore>(bst, buf);
|
||
WRITE_SEP();
|
||
o.append("Xs:i:");
|
||
o.append(buf);
|
||
}
|
||
if(flags.partOfPair()) {
|
||
// Ys:i: Best invalid alignment score of opposite mate
|
||
bst = one ? prm.bestLtMinscMate2 : prm.bestLtMinscMate1;
|
||
if(bst > std::numeric_limits<TAlScore>::min()) {
|
||
itoa10<TAlScore>(bst, buf);
|
||
WRITE_SEP();
|
||
o.append("Ys:i:");
|
||
o.append(buf);
|
||
}
|
||
}
|
||
}
|
||
if(print_zs_) {
|
||
// ZS:i: Pseudo-random seed for read
|
||
itoa10<uint32_t>(rd.seed, buf);
|
||
WRITE_SEP();
|
||
o.append("ZS:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yt_ && !threeN) {
|
||
// YT:Z: String representing alignment type
|
||
WRITE_SEP();
|
||
flags.printYT(o);
|
||
}
|
||
if(print_yp_ && flags.partOfPair() && flags.canMax()) {
|
||
// YP:i: Read was repetitive when aligned paired?
|
||
WRITE_SEP();
|
||
flags.printYP(o);
|
||
}
|
||
if(print_ym_ && flags.canMax() && (flags.isMixedMode() || !flags.partOfPair())) {
|
||
// YM:i: Read was repetitive when aligned unpaired?
|
||
WRITE_SEP();
|
||
flags.printYM(o);
|
||
}
|
||
if(print_yf_ && flags.filtered()) {
|
||
// YF:i: Read was filtered?
|
||
first = flags.printYF(o, first) && first;
|
||
}
|
||
if(print_yi_) {
|
||
// Print MAPQ calibration info
|
||
if(mapqInp[0] != '\0') {
|
||
// YI:i: Suboptimal alignment score
|
||
WRITE_SEP();
|
||
o.append("YI:Z:");
|
||
o.append(mapqInp);
|
||
}
|
||
}
|
||
if(flags.partOfPair() && print_zp_) {
|
||
// ZP:i: Score of best concordant paired-end alignment
|
||
WRITE_SEP();
|
||
o.append("ZP:Z:");
|
||
if(summ.bestPaired().valid()) {
|
||
itoa10<TAlScore>(summ.bestPaired().score(), buf);
|
||
o.append(buf);
|
||
} else {
|
||
o.append("NA");
|
||
}
|
||
// Zp:i: Second-best concordant paired-end alignment score
|
||
WRITE_SEP();
|
||
o.append("Zp:Z:");
|
||
if(summ.secbestPaired().valid()) {
|
||
itoa10<TAlScore>(summ.secbestPaired().score(), buf);
|
||
o.append(buf);
|
||
} else {
|
||
o.append("NA");
|
||
}
|
||
}
|
||
if(print_zu_) {
|
||
// ZU:i: Score of best unpaired alignment
|
||
AlnScore best = (rd.mate <= 1 ? summ.best1() : summ.best2());
|
||
AlnScore secbest = (rd.mate <= 1 ? summ.secbest1() : summ.secbest2());
|
||
WRITE_SEP();
|
||
o.append("ZU:i:");
|
||
if(best.valid()) {
|
||
itoa10<TAlScore>(best.score(), buf);
|
||
o.append(buf);
|
||
} else {
|
||
o.append("NA");
|
||
}
|
||
// Zu:i: Score of second-best unpaired alignment
|
||
WRITE_SEP();
|
||
o.append("Zu:i:");
|
||
if(secbest.valid()) {
|
||
itoa10<TAlScore>(secbest.score(), buf);
|
||
o.append(buf);
|
||
} else {
|
||
o.append("NA");
|
||
}
|
||
}
|
||
if(!rgs_.empty()) {
|
||
WRITE_SEP();
|
||
o.append(rgs_.c_str());
|
||
}
|
||
if(print_xt_) {
|
||
// XT:i: Timing
|
||
WRITE_SEP();
|
||
struct timeval tv_end;
|
||
struct timezone tz_end;
|
||
gettimeofday(&tv_end, &tz_end);
|
||
size_t total_usecs =
|
||
(tv_end.tv_sec - prm.tv_beg.tv_sec) * 1000000 +
|
||
(tv_end.tv_usec - prm.tv_beg.tv_usec);
|
||
itoa10<size_t>(total_usecs, buf);
|
||
o.append("XT:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xd_) {
|
||
// XD:i: Extend DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExDps, buf);
|
||
o.append("XD:i:");
|
||
o.append(buf);
|
||
// Xd:i: Mate DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nMateDps, buf);
|
||
o.append("Xd:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xu_) {
|
||
// XU:i: Extend ungapped tries
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExUgs, buf);
|
||
o.append("XU:i:");
|
||
o.append(buf);
|
||
// Xu:i: Mate ungapped tries
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nMateUgs, buf);
|
||
o.append("Xu:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_ye_) {
|
||
// YE:i: Streak of failed DPs at end
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpFail, buf);
|
||
o.append("YE:i:");
|
||
o.append(buf);
|
||
// Ye:i: Streak of failed ungaps at end
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgFail, buf);
|
||
o.append("Ye:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yl_) {
|
||
// YL:i: Longest streak of failed DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpFailStreak, buf);
|
||
o.append("YL:i:");
|
||
o.append(buf);
|
||
// Yl:i: Longest streak of failed ungaps
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgFailStreak, buf);
|
||
o.append("Yl:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yu_) {
|
||
// YU:i: Index of last succesful DP
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpLastSucc, buf);
|
||
o.append("YU:i:");
|
||
o.append(buf);
|
||
// Yu:i: Index of last succesful DP
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgLastSucc, buf);
|
||
o.append("Yu:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xp_) {
|
||
// XP:Z: String describing seed hits
|
||
WRITE_SEP();
|
||
o.append("XP:B:I,");
|
||
itoa10<uint64_t>(prm.nSeedElts, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nSeedEltsFw, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nSeedEltsRc, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.seedMean, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.seedMedian, buf);
|
||
o.append(buf);
|
||
}
|
||
if(print_yr_) {
|
||
// YR:i: Redundant seed hits
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nRedundants, buf);
|
||
o.append("YR:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zb_) {
|
||
// ZB:i: Ftab ops for seed alignment
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nFtabs, buf);
|
||
o.append("ZB:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zr_) {
|
||
// ZR:Z: Redundant path skips in seed alignment
|
||
WRITE_SEP();
|
||
o.append("ZR:Z:");
|
||
itoa10<uint64_t>(prm.nRedSkip, buf); o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nRedFail, buf); o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nRedIns, buf); o.append(buf);
|
||
}
|
||
if(print_zf_) {
|
||
// ZF:i: FM Index ops for seed alignment
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nSdFmops, buf);
|
||
o.append("ZF:i:");
|
||
o.append(buf);
|
||
// Zf:i: FM Index ops for offset resolution
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExFmops, buf);
|
||
o.append("Zf:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zm_) {
|
||
// ZM:Z: Print FM index op string for best-first search
|
||
WRITE_SEP();
|
||
o.append("ZM:Z:");
|
||
prm.fmString.print(o, buf);
|
||
}
|
||
if(print_zi_) {
|
||
// ZI:i: Seed extend loop iterations
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExIters, buf);
|
||
o.append("ZI:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xs_a_) {
|
||
if(rna_strandness_ == RNA_STRANDNESS_UNKNOWN) {
|
||
uint8_t whichsense = res.spliced_whichsense_transcript();
|
||
if(whichsense != SPL_UNKNOWN) {
|
||
WRITE_SEP();
|
||
o.append("XS:A:");
|
||
if(whichsense == SPL_FW || whichsense == SPL_SEMI_FW) {
|
||
o.append('+');
|
||
} else {
|
||
assert(whichsense == SPL_RC || whichsense == SPL_SEMI_RC);
|
||
o.append('-');
|
||
}
|
||
}
|
||
} else {
|
||
WRITE_SEP();
|
||
o.append("XS:A:");
|
||
char strandness = '+';
|
||
if(res.readMate1()) {
|
||
if(res.orient()) {
|
||
if(rna_strandness_ == RNA_STRANDNESS_R || rna_strandness_ == RNA_STRANDNESS_RF) {
|
||
strandness = '-';
|
||
}
|
||
} else {
|
||
if(rna_strandness_ == RNA_STRANDNESS_F || rna_strandness_ == RNA_STRANDNESS_FR) {
|
||
strandness = '-';
|
||
}
|
||
}
|
||
} else {
|
||
assert(res.readMate2());
|
||
assert(rna_strandness_ == RNA_STRANDNESS_FR || rna_strandness_ == RNA_STRANDNESS_RF);
|
||
if(res.orient()) {
|
||
if(rna_strandness_ == RNA_STRANDNESS_FR) {
|
||
strandness = '-';
|
||
}
|
||
} else {
|
||
if(rna_strandness_ == RNA_STRANDNESS_RF) {
|
||
strandness = '-';
|
||
}
|
||
}
|
||
}
|
||
o.append(strandness);
|
||
}
|
||
}
|
||
if(print_nh_) {
|
||
if(flags.alignedPaired()) {
|
||
/*WRITE_SEP();
|
||
itoa10<uint64_t>(summ.numAlnsPaired(), buf);
|
||
o.append("NH:i:");
|
||
o.append(buf);*/
|
||
newAlignment->NH = summ.numAlnsPaired();
|
||
} else if(flags.alignedUnpaired() || flags.alignedUnpairedMate()) {
|
||
/*WRITE_SEP();
|
||
itoa10<uint64_t>((flags.alignedUnpaired() || flags.readMate1()) ?
|
||
summ.numAlns1() : summ.numAlns2(), buf);
|
||
o.append("NH:i:");
|
||
o.append(buf);*/
|
||
newAlignment->NH = (flags.alignedUnpaired() || flags.readMate1()) ? summ.numAlns1() : summ.numAlns2();
|
||
}
|
||
}
|
||
|
||
bool snp_first = true;
|
||
index_t prev_snp_idx = INDEX_MAX;
|
||
size_t len_trimmed = rd.length() - res.trimmed5p(true) - res.trimmed3p(true);
|
||
if(!res.fw()) {
|
||
Edit::invertPoss(const_cast<EList<Edit>&>(res.ned()), len_trimmed, false);
|
||
}
|
||
for(size_t i = 0; i < res.ned().size(); i++) {
|
||
if(res.ned()[i].snpID >= altdb->alts().size())
|
||
continue;
|
||
index_t snp_idx = res.ned()[i].snpID;
|
||
assert_lt(snp_idx, altdb->alts().size());
|
||
const ALT<index_t>& snp = altdb->alts()[snp_idx];
|
||
const string& snpID = altdb->altnames()[snp_idx];
|
||
if(snp_idx == prev_snp_idx) continue;
|
||
if(snp_first) {
|
||
WRITE_SEP();
|
||
o.append("Zs:Z:");
|
||
}
|
||
if(!snp_first) o.append(",");
|
||
uint64_t pos = res.ned()[i].pos;
|
||
size_t j = i;
|
||
while(j > 0) {
|
||
if(res.ned()[j-1].snpID < altdb->alts().size()) {
|
||
const ALT<index_t>& snp2 = altdb->alts()[res.ned()[j-1].snpID];
|
||
if(snp2.type == ALT_SNP_SGL) {
|
||
pos -= (res.ned()[j-1].pos + 1);
|
||
} else if(snp2.type == ALT_SNP_DEL) {
|
||
pos -= res.ned()[j-1].pos;
|
||
} else if(snp2.type == ALT_SNP_INS) {
|
||
pos -= (res.ned()[j-1].pos + snp.len);
|
||
}
|
||
break;
|
||
}
|
||
j--;
|
||
}
|
||
itoa10<uint64_t>(pos, buf);
|
||
o.append(buf);
|
||
o.append("|");
|
||
if(snp.type == ALT_SNP_SGL) {
|
||
o.append("S");
|
||
} else if(snp.type == ALT_SNP_DEL) {
|
||
o.append("D");
|
||
} else {
|
||
assert_eq(snp.type, ALT_SNP_INS);
|
||
o.append("I");
|
||
}
|
||
o.append("|");
|
||
o.append(snpID.c_str());
|
||
|
||
if(snp_first) snp_first = false;
|
||
prev_snp_idx = snp_idx;
|
||
}
|
||
if(!res.fw()) {
|
||
Edit::invertPoss(const_cast<EList<Edit>&>(res.ned()), len_trimmed, false);
|
||
}
|
||
|
||
if(print_xr_) {
|
||
// Original read string
|
||
newAlignment->passThroughLine.append("\n");
|
||
printOptFieldNewlineEscapedZ(newAlignment->passThroughLine, rd.readOrigBuf);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Print the optional flags to the given string.
|
||
*/
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printEmptyOptFlags(
|
||
BTString& o, // output buffer
|
||
bool first, // first opt flag printed is first overall?
|
||
const Read& rd, // read
|
||
const AlnFlags& flags, // alignment flags
|
||
const AlnSetSumm& summ, // summary of alignments for this read
|
||
const SeedAlSumm& ssm, // seed alignment summary
|
||
const PerReadMetrics& prm, // per-read metrics
|
||
const Scoring& sc) // scoring scheme
|
||
const
|
||
{
|
||
char buf[1024];
|
||
if(print_yn_) {
|
||
// YN:i: Minimum valid score for this mate
|
||
TAlScore mn = sc.scoreMin.f<TAlScore>(rd.length());
|
||
itoa10<TAlScore>(mn, buf);
|
||
WRITE_SEP();
|
||
o.append("YN:i:");
|
||
o.append(buf);
|
||
// Yn:i: Perfect score for this mate
|
||
TAlScore pe = sc.perfectScore(rd.length());
|
||
itoa10<TAlScore>(pe, buf);
|
||
WRITE_SEP();
|
||
o.append("Yn:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zs_) {
|
||
// ZS:i: Pseudo-random seed for read
|
||
itoa10<uint32_t>(rd.seed, buf);
|
||
WRITE_SEP();
|
||
o.append("ZS:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yt_&& !threeN) {
|
||
// YT:Z: String representing alignment type
|
||
WRITE_SEP();
|
||
flags.printYT(o);
|
||
}
|
||
if(print_yp_ && flags.partOfPair() && flags.canMax()) {
|
||
// YP:i: Read was repetitive when aligned paired?
|
||
WRITE_SEP();
|
||
flags.printYP(o);
|
||
}
|
||
if(print_ym_ && flags.canMax() && (flags.isMixedMode() || !flags.partOfPair())) {
|
||
// YM:i: Read was repetitive when aligned unpaired?
|
||
WRITE_SEP();
|
||
flags.printYM(o);
|
||
}
|
||
if(print_yf_ && flags.filtered()) {
|
||
// YM:i: Read was repetitive when aligned unpaired?
|
||
first = flags.printYF(o, first) && first;
|
||
}
|
||
if(!rgs_.empty()) {
|
||
WRITE_SEP();
|
||
o.append(rgs_.c_str());
|
||
}
|
||
if(print_xt_) {
|
||
// XT:i: Timing
|
||
WRITE_SEP();
|
||
struct timeval tv_end;
|
||
struct timezone tz_end;
|
||
gettimeofday(&tv_end, &tz_end);
|
||
size_t total_usecs =
|
||
(tv_end.tv_sec - prm.tv_beg.tv_sec) * 1000000 +
|
||
(tv_end.tv_usec - prm.tv_beg.tv_usec);
|
||
itoa10<size_t>(total_usecs, buf);
|
||
o.append("XT:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xd_) {
|
||
// XD:i: Extend DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExDps, buf);
|
||
o.append("XD:i:");
|
||
o.append(buf);
|
||
// Xd:i: Mate DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nMateDps, buf);
|
||
o.append("Xd:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xu_) {
|
||
// XU:i: Extend ungapped tries
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExUgs, buf);
|
||
o.append("XU:i:");
|
||
o.append(buf);
|
||
// Xu:i: Mate ungapped tries
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nMateUgs, buf);
|
||
o.append("Xu:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_ye_) {
|
||
// YE:i: Streak of failed DPs at end
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpFail, buf);
|
||
o.append("YE:i:");
|
||
o.append(buf);
|
||
// Ye:i: Streak of failed ungaps at end
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgFail, buf);
|
||
o.append("Ye:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yl_) {
|
||
// YL:i: Longest streak of failed DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpFailStreak, buf);
|
||
o.append("YL:i:");
|
||
o.append(buf);
|
||
// Yl:i: Longest streak of failed ungaps
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgFailStreak, buf);
|
||
o.append("Yl:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yu_) {
|
||
// YU:i: Index of last succesful DP
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpLastSucc, buf);
|
||
o.append("YU:i:");
|
||
o.append(buf);
|
||
// Yu:i: Index of last succesful DP
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgLastSucc, buf);
|
||
o.append("Yu:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xp_) {
|
||
// XP:Z: String describing seed hits
|
||
WRITE_SEP();
|
||
o.append("XP:B:I,");
|
||
itoa10<uint64_t>(prm.nSeedElts, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nSeedEltsFw, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nSeedEltsRc, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.seedMean, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.seedMedian, buf);
|
||
o.append(buf);
|
||
}
|
||
if(print_yr_) {
|
||
// YR:i: Redundant seed hits
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nRedundants, buf);
|
||
o.append("YR:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zb_) {
|
||
// ZB:i: Ftab ops for seed alignment
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nFtabs, buf);
|
||
o.append("ZB:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zr_) {
|
||
// ZR:Z: Redundant path skips in seed alignment
|
||
WRITE_SEP();
|
||
o.append("ZR:Z:");
|
||
itoa10<uint64_t>(prm.nRedSkip, buf); o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nRedFail, buf); o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nRedIns, buf); o.append(buf);
|
||
}
|
||
if(print_zf_) {
|
||
// ZF:i: FM Index ops for seed alignment
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nSdFmops, buf);
|
||
o.append("ZF:i:");
|
||
o.append(buf);
|
||
// Zf:i: FM Index ops for offset resolution
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExFmops, buf);
|
||
o.append("Zf:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zm_) {
|
||
// ZM:Z: Print FM index op string for best-first search
|
||
WRITE_SEP();
|
||
o.append("ZM:Z:");
|
||
prm.fmString.print(o, buf);
|
||
}
|
||
if(print_zi_) {
|
||
// ZI:i: Seed extend loop iterations
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExIters, buf);
|
||
o.append("ZI:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xr_) {
|
||
// Original read string
|
||
o.append("\n");
|
||
printOptFieldNewlineEscapedZ(o, rd.readOrigBuf);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Print the optional flags to the given string. This function is for HISAT-3N.
|
||
*/
|
||
|
||
template<typename index_t>
|
||
void SamConfig<index_t>::printEmptyOptFlags(
|
||
Alignment* newAlignment, // output buffer
|
||
bool first, // first opt flag printed is first overall?
|
||
const Read& rd, // read
|
||
const AlnFlags& flags, // alignment flags
|
||
const AlnSetSumm& summ, // summary of alignments for this read
|
||
const SeedAlSumm& ssm, // seed alignment summary
|
||
const PerReadMetrics& prm, // per-read metrics
|
||
const Scoring& sc) // scoring scheme
|
||
const
|
||
{
|
||
char buf[1024];
|
||
BTString &o = newAlignment->unChangedTags;
|
||
if(print_yn_) {
|
||
// YN:i: Minimum valid score for this mate
|
||
TAlScore mn = sc.scoreMin.f<TAlScore>(rd.length());
|
||
itoa10<TAlScore>(mn, buf);
|
||
WRITE_SEP();
|
||
o.append("YN:i:");
|
||
o.append(buf);
|
||
// Yn:i: Perfect score for this mate
|
||
TAlScore pe = sc.perfectScore(rd.length());
|
||
itoa10<TAlScore>(pe, buf);
|
||
WRITE_SEP();
|
||
o.append("Yn:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zs_) {
|
||
// ZS:i: Pseudo-random seed for read
|
||
itoa10<uint32_t>(rd.seed, buf);
|
||
WRITE_SEP();
|
||
o.append("ZS:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yt_&& !threeN) {
|
||
// YT:Z: String representing alignment type
|
||
WRITE_SEP();
|
||
flags.printYT(o);
|
||
}
|
||
if(print_yp_ && flags.partOfPair() && flags.canMax()) {
|
||
// YP:i: Read was repetitive when aligned paired?
|
||
WRITE_SEP();
|
||
flags.printYP(o);
|
||
}
|
||
if(print_ym_ && flags.canMax() && (flags.isMixedMode() || !flags.partOfPair())) {
|
||
// YM:i: Read was repetitive when aligned unpaired?
|
||
WRITE_SEP();
|
||
flags.printYM(o);
|
||
}
|
||
if(print_yf_ && flags.filtered()) {
|
||
// YM:i: Read was repetitive when aligned unpaired?
|
||
first = flags.printYF(o, first) && first;
|
||
}
|
||
if(!rgs_.empty()) {
|
||
WRITE_SEP();
|
||
o.append(rgs_.c_str());
|
||
}
|
||
if(print_xt_) {
|
||
// XT:i: Timing
|
||
WRITE_SEP();
|
||
struct timeval tv_end;
|
||
struct timezone tz_end;
|
||
gettimeofday(&tv_end, &tz_end);
|
||
size_t total_usecs =
|
||
(tv_end.tv_sec - prm.tv_beg.tv_sec) * 1000000 +
|
||
(tv_end.tv_usec - prm.tv_beg.tv_usec);
|
||
itoa10<size_t>(total_usecs, buf);
|
||
o.append("XT:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xd_) {
|
||
// XD:i: Extend DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExDps, buf);
|
||
o.append("XD:i:");
|
||
o.append(buf);
|
||
// Xd:i: Mate DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nMateDps, buf);
|
||
o.append("Xd:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xu_) {
|
||
// XU:i: Extend ungapped tries
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExUgs, buf);
|
||
o.append("XU:i:");
|
||
o.append(buf);
|
||
// Xu:i: Mate ungapped tries
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nMateUgs, buf);
|
||
o.append("Xu:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_ye_) {
|
||
// YE:i: Streak of failed DPs at end
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpFail, buf);
|
||
o.append("YE:i:");
|
||
o.append(buf);
|
||
// Ye:i: Streak of failed ungaps at end
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgFail, buf);
|
||
o.append("Ye:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yl_) {
|
||
// YL:i: Longest streak of failed DPs
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpFailStreak, buf);
|
||
o.append("YL:i:");
|
||
o.append(buf);
|
||
// Yl:i: Longest streak of failed ungaps
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgFailStreak, buf);
|
||
o.append("Yl:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_yu_) {
|
||
// YU:i: Index of last succesful DP
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nDpLastSucc, buf);
|
||
o.append("YU:i:");
|
||
o.append(buf);
|
||
// Yu:i: Index of last succesful DP
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nUgLastSucc, buf);
|
||
o.append("Yu:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xp_) {
|
||
// XP:Z: String describing seed hits
|
||
WRITE_SEP();
|
||
o.append("XP:B:I,");
|
||
itoa10<uint64_t>(prm.nSeedElts, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nSeedEltsFw, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nSeedEltsRc, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.seedMean, buf);
|
||
o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.seedMedian, buf);
|
||
o.append(buf);
|
||
}
|
||
if(print_yr_) {
|
||
// YR:i: Redundant seed hits
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nRedundants, buf);
|
||
o.append("YR:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zb_) {
|
||
// ZB:i: Ftab ops for seed alignment
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nFtabs, buf);
|
||
o.append("ZB:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zr_) {
|
||
// ZR:Z: Redundant path skips in seed alignment
|
||
WRITE_SEP();
|
||
o.append("ZR:Z:");
|
||
itoa10<uint64_t>(prm.nRedSkip, buf); o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nRedFail, buf); o.append(buf);
|
||
o.append(',');
|
||
itoa10<uint64_t>(prm.nRedIns, buf); o.append(buf);
|
||
}
|
||
if(print_zf_) {
|
||
// ZF:i: FM Index ops for seed alignment
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nSdFmops, buf);
|
||
o.append("ZF:i:");
|
||
o.append(buf);
|
||
// Zf:i: FM Index ops for offset resolution
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExFmops, buf);
|
||
o.append("Zf:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_zm_) {
|
||
// ZM:Z: Print FM index op string for best-first search
|
||
WRITE_SEP();
|
||
o.append("ZM:Z:");
|
||
prm.fmString.print(o, buf);
|
||
}
|
||
if(print_zi_) {
|
||
// ZI:i: Seed extend loop iterations
|
||
WRITE_SEP();
|
||
itoa10<uint64_t>(prm.nExIters, buf);
|
||
o.append("ZI:i:");
|
||
o.append(buf);
|
||
}
|
||
if(print_xr_) {
|
||
// Original read string
|
||
newAlignment->passThroughLine.append("\n");
|
||
printOptFieldNewlineEscapedZ(newAlignment->passThroughLine, rd.readOrigBuf);
|
||
}
|
||
}
|
||
|
||
#endif /* SAM_H_ */
|