557 lines
22 KiB
C++
557 lines
22 KiB
C++
/*
|
||
Description:
|
||
bam，bam，bam
|
||
|
||
Copyright : All right reserved by ICT
|
||
|
||
Author : Zhang Zhonghai
|
||
Date : 2023/10/23
|
||
*/
|
||
#include <header.h>
|
||
#include <htslib/faidx.h>
|
||
#include <htslib/kstring.h>
|
||
#include <htslib/sam.h>
|
||
#include <htslib/synced_bcf_reader.h>
|
||
#include <htslib/thread_pool.h>
|
||
#include <klib/kthread.h>
|
||
#include <spdlog/spdlog.h>
|
||
|
||
#include <iomanip>
|
||
#include <numeric>
|
||
#include <queue>
|
||
#include <vector>
|
||
|
||
#include "aux_arg.h"
|
||
#include "baq.h"
|
||
#include "bqsr_args.h"
|
||
#include "covariate.h"
|
||
#include "fastbqsr_version.h"
|
||
#include "quant_info.h"
|
||
#include "read_recal_info.h"
|
||
#include "recal_datum.h"
|
||
#include "recal_funcs.h"
|
||
#include "recal_tables.h"
|
||
#include "recal_utils.h"
|
||
#include "util/bam_buf.h"
|
||
#include "util/base_utils.h"
|
||
#include "util/debug.h"
|
||
#include "util/interval.h"
|
||
#include "util/linear_index.h"
|
||
#include "util/math/math_utils.h"
|
||
#include "util/profiling.h"
|
||
#include "util/read_transformer.h"
|
||
#include "util/sam_data.h"
|
||
#include "util/stable_array.h"
|
||
#include "util/utils.h"
|
||
#include "util/vcf_parser.h"
|
||
|
||
using std::deque;
|
||
|
||
#define BAM_BLOCK_SIZE 16L * 1024 * 1024 // 16M
|
||
|
||
namespace nsgv {
|
||
|
||
// 全局变量 for bqsr
|
||
BQSRArg gBqsrArg; // bqsr arguments
|
||
samFile* gInBamFp; // input BAM file pointer
|
||
sam_hdr_t* gInBamHeader; // input BAM header
|
||
vector<AuxVar> gAuxVars; // auxiliary variables，保存一些文件，数据等，每个线程对应一个
|
||
}; // namespace nsgv
|
||
|
||
|
||
// 过滤掉bqsr过程不符合要求的bam数据
|
||
bool bqsrReadFilterOut(const bam1_t *b) {
|
||
// 过滤掉unmapped的read
|
||
if (b->core.qual == 0) // mapping quality 0
|
||
return true;
|
||
if (b->core.qual == 255) // mapping quality not available
|
||
return true;
|
||
if (b->core.flag & BAM_FUNMAP || b->core.tid == -1 || b->core.pos == -1) { // unmapped
|
||
return true;
|
||
}
|
||
if (b->core.flag & BAM_FSECONDARY) { // secondary alignment
|
||
return true;
|
||
}
|
||
if (b->core.flag & BAM_FDUP) { // secondary alignment
|
||
return true;
|
||
}
|
||
if (b->core.flag & BAM_FQCFAIL) { // Not passing quality controls
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 数据总结
|
||
void collapseQualityScoreTableToReadGroupTable(Array2D<RecalDatum> &byReadGroupTable, Array3D<RecalDatum> &byQualTable) {
|
||
// 遍历quality table
|
||
_Foreach3DK(byQualTable, qualDatum, {
|
||
if (qualDatum.numObservations > 0) {
|
||
byReadGroupTable(k1, k2).combine(qualDatum);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* To replicate the results of BQSR whether or not we save tables to disk (which we need in Spark),
|
||
* we need to trim the numbers to a few decimal placed (that's what writing and reading does).
|
||
*/
|
||
void roundTableValues(RecalTables& rt) {
|
||
#define _round_val(val) \
|
||
do { \
|
||
if (val.numObservations > 0) { \
|
||
val.numMismatches = MathUtils::RoundToNDecimalPlaces(val.numMismatches, RecalUtils::NUMBER_ERRORS_DECIMAL_PLACES); \
|
||
val.reportedQuality = MathUtils::RoundToNDecimalPlaces(val.reportedQuality, RecalUtils::REPORTED_QUALITY_DECIMAL_PLACES); \
|
||
} \
|
||
} while (0)
|
||
|
||
_Foreach2D(rt.readGroupTable, val, { _round_val(val); });
|
||
_Foreach3D(rt.qualityScoreTable, val, { _round_val(val); });
|
||
_Foreach4D(rt.contextTable, val, { _round_val(val); });
|
||
_Foreach4D(rt.cycleTable, val, { _round_val(val); });
|
||
}
|
||
|
||
// 打印recal tables，用于调试
|
||
static void printRecalTables(const RecalTables& rt) {
|
||
_Foreach2D(rt.readGroupTable, val, {
|
||
if (val.numObservations > 0) {
|
||
fprintf(gf[0], "%ld %f %f\n", val.numObservations, val.getNumMismatches(), val.reportedQuality);
|
||
}
|
||
});
|
||
_Foreach3D(rt.qualityScoreTable, val, {
|
||
if (val.numObservations > 0) {
|
||
fprintf(gf[1], "%ld %f %f\n", val.numObservations, val.getNumMismatches(), val.reportedQuality);
|
||
}
|
||
});
|
||
_Foreach4D(rt.contextTable, val, {
|
||
if (val.numObservations > 0) {
|
||
fprintf(gf[2], "%ld %f %f\n", val.numObservations, val.getNumMismatches(), val.reportedQuality);
|
||
}
|
||
});
|
||
_Foreach4D(rt.cycleTable, val, {
|
||
if (val.numObservations > 0) {
|
||
fprintf(gf[3], "%ld %f %f\n", val.numObservations, val.getNumMismatches(), val.reportedQuality);
|
||
}
|
||
});
|
||
}
|
||
|
||
// 串行bqsr
|
||
int SerialBQSR(AuxVar &aux) {
|
||
BamBufType inBamBuf(nsgv::gBqsrArg.DUPLEX_IO);
|
||
inBamBuf.Init(nsgv::gInBamFp, nsgv::gInBamHeader, nsgv::gBqsrArg.MAX_MEM, bqsrReadFilterOut);
|
||
int64_t readNumSum = 0;
|
||
int round = 0;
|
||
|
||
PerReadCovariateMatrix &readCovariates = aux.readCovariates;
|
||
RecalTables& recalTables = aux.recalTables;
|
||
SamData& sd = aux.sd;
|
||
StableArray<int>&isSNP = aux.isSNP, &isIns = aux.isIns, &isDel = aux.isDel; // 该位置是否是SNP, indel位置，0不是，1是
|
||
StableArray<uint8_t> &baqArray = aux.baqArray;
|
||
StableArray<double> &snpErrors = aux.snpErrors, &insErrors = aux.insErrors, &delErrors = aux.delErrors;
|
||
StableArray<uint8_t> &skips = aux.skips; // 该位置是否是已知位点
|
||
|
||
while (true) {
|
||
++round;
|
||
// 一. 读取bam数据
|
||
size_t readNum = 0;
|
||
if (inBamBuf.ReadStat() >= 0)
|
||
readNum = inBamBuf.ReadBam();
|
||
if (readNum < 1) {
|
||
break;
|
||
}
|
||
auto bams = inBamBuf.GetBamArr();
|
||
spdlog::info("{} reads processed in {} round", readNum, round);
|
||
|
||
// 二. 遍历每个bam（read）记录，进行处理
|
||
for (int i = 0; i < bams.size(); ++i) {
|
||
// 1.
|
||
// 对每个read，需要检查cigar是否合法，即没有两个连续的相同的cigar，而且需要将首尾的deletion处理掉，目前看好像没啥影响，我们忽略这一步
|
||
// 2. 对质量分数长度跟碱基长度不匹配的read，缺少的质量分数用默认值补齐，先忽略，后边有需要再处理
|
||
// 3. 如果bam文件之前做过bqsr，tag中包含OQ（originnal
|
||
// quality，原始质量分数），检查用户参数里是否指定用原始质量分数进行bqsr，如果是则将质量分数替换为OQ，否则忽略OQ，先忽略
|
||
// spdlog::info("bam idx: {}", i);
|
||
BamWrap* bw = bams[i];
|
||
sd.init();
|
||
sd.parseBasic(bw);
|
||
sd.rid = i + readNumSum;
|
||
if (sd.read_len <= 0)
|
||
continue;
|
||
|
||
PROF_START(clip_read);
|
||
// 4. 对read的两端进行检测，去除（hardclip）adapter
|
||
ReadTransformer::hardClipAdaptorSequence(bw, sd);
|
||
if (sd.read_len <= 0)
|
||
continue;
|
||
// 5. 然后再去除softclip部分
|
||
ReadTransformer::hardClipSoftClippedBases(bw, sd);
|
||
if (sd.read_len <= 0)
|
||
continue;
|
||
// 应用所有的变换，计算samdata的相关信息
|
||
sd.applyTransformations();
|
||
PROF_END(gprof[GP_clip_read], clip_read);
|
||
|
||
//const char* qname = bam_get_qname(sd.bw->b);
|
||
// fprintf(gf[4], "%ld %d %d %d\n", sd.rid, sd.read_len, 1 + BamWrap::bam_pos(sd.start_pos), 1 + BamWrap::bam_pos(sd.end_pos));
|
||
//fprintf(gf[4], "%s %d %d %d %d\n", qname, sd.bw->b->core.flag, sd.read_len, 1 + BamWrap::bam_pos(sd.start_pos), 1 + BamWrap::bam_pos(sd.end_pos));
|
||
|
||
// 6. 更新每个read的platform信息，好像没啥用，暂时忽略
|
||
// 这里计算snp和indel有点问题，snp和del结果不对，白天调试一下
|
||
const int nErrors = RecalFuncs::calculateIsSNPOrIndel(aux, sd, isSNP, isIns, isDel);
|
||
|
||
// fprintf(gf[4], "%s %d %ld ", bam_get_qname(sd.bw->b), sd.bw->b->core.flag, sd.rid);
|
||
// for (int ii = 0; ii < sd.read_len; ++ii) fprintf(gf[4], "%d ", skips[ii] ? 1 : 0);
|
||
// fprintf(gf[4], "\n");
|
||
|
||
// fprintf(gf[0], "%s %d %ld ", bam_get_qname(sd.bw->b), sd.bw->b->core.flag, sd.rid);
|
||
// for (int ii = 0; ii < sd.read_len; ++ii) fprintf(gf[0], "%d ", isSNP[ii]); fprintf(gf[0], "\n");
|
||
// fprintf(gf[1], "%s %d %ld ", bam_get_qname(sd.bw->b), sd.bw->b->core.flag, sd.rid);
|
||
// for (int ii = 0; ii < sd.read_len; ++ii) fprintf(gf[1], "%d ", isIns[ii]); fprintf(gf[1], "\n");
|
||
// fprintf(gf[2], "%s %d %ld ", bam_get_qname(sd.bw->b), sd.bw->b->core.flag, sd.rid);
|
||
// for (int ii = 0; ii < sd.read_len; ++ii) fprintf(gf[2], "%d ", isDel[ii]); fprintf(gf[2], "\n");
|
||
|
||
// 7. 计算baqArray
|
||
// BAQ = base alignment quality
|
||
// note for efficiency reasons we don't compute the BAQ array unless we actually have
|
||
// some error to marginalize over. For ILMN data ~85% of reads have no error
|
||
// vector<uint8_t> baqArray;
|
||
bool baqCalculated = false;
|
||
if (nErrors == 0 || !nsgv::gBqsrArg.enableBAQ) {
|
||
baqCalculated = BAQ::flatBAQArray(sd, baqArray);
|
||
} else {
|
||
// baqCalculated = calculateBAQArray(nsgv::gAuxVars[0], baq, sd, baqArray);
|
||
}
|
||
if (!baqCalculated)
|
||
continue;
|
||
// 到这里，基本的数据都准备好了，后续就是进行bqsr的统计了
|
||
|
||
// 8. 计算这条read对应的协变量
|
||
PROF_START(covariate);
|
||
CovariateUtils::ComputeCovariates(sd, aux.header, readCovariates, true);
|
||
PROF_END(gprof[GP_covariate], covariate);
|
||
|
||
// fprintf(gf[4], "%ld %d\n", sd.rid, sd.read_len);
|
||
// for (auto &arr1 : readCovariates) {
|
||
// for (size_t si = 0; si < sd.read_len; ++si) {
|
||
// fprintf(gf[4], "%d %d %d %d ", arr1[si].readGroup, arr1[si].baseQuality, arr1[si].context, arr1[si].cycle);
|
||
// }
|
||
// }
|
||
// fprintf(gf[4], "\n");
|
||
|
||
// fprintf(gf[3], "%ld %d\n", sd.rid, sd.read_len);
|
||
// {
|
||
// auto& arr1 = readCovariates[0];
|
||
// {
|
||
// for (int pos = 0; pos < sd.read_len; ++pos) {
|
||
// fprintf(gf[3], "%d %d\n", pos, arr1[pos][2]);
|
||
// }
|
||
// }
|
||
// }
|
||
// fprintf(gf[3], "\n");
|
||
|
||
// 9. 计算这条read需要跳过的位置
|
||
PROF_START(read_vcf);
|
||
RecalFuncs::calculateKnownSites(sd, aux.vcfArr, aux.header, skips);
|
||
for (int ii = 0; ii < sd.read_len; ++ii) {
|
||
skips[ii] = skips[ii] || (ContextCovariate::baseIndexMap[sd.bases[ii]] == -1) ||
|
||
sd.base_quals[ii] < nsgv::gBqsrArg.PRESERVE_QSCORES_LESS_THAN;
|
||
}
|
||
//stringstream ss;
|
||
//for (auto s : skips) ss << (int)s << ' ';
|
||
//spdlog::info("{}", ss.str());
|
||
PROF_GP_END(read_vcf);
|
||
|
||
// fprintf(gf[3], "%s %d %ld ", bam_get_qname(sd.bw->b), sd.bw->b->core.flag, sd.rid);
|
||
// for (int ii = 0; ii < sd.read_len; ++ii) fprintf(gf[3], "%d ", skips[ii] ? 1 : 0);
|
||
// fprintf(gf[3], "\n");
|
||
|
||
// fprintf(gf[0], "%ld %d\t", sd.rid, sd.read_len);
|
||
// for (int ii = 0; ii < sd.read_len; ++ii) fprintf(gf[0], "%d ", skips[ii] ? 1 : 0);
|
||
// fprintf(gf[0], "\n");
|
||
|
||
// 10. 根据BAQ进一步处理snp，indel，得到处理后的数据
|
||
PROF_START(frac_err);
|
||
RecalFuncs::calculateFractionalErrorArray(isSNP, baqArray, snpErrors);
|
||
RecalFuncs::calculateFractionalErrorArray(isIns, baqArray, insErrors);
|
||
RecalFuncs::calculateFractionalErrorArray(isDel, baqArray, delErrors);
|
||
PROF_GP_END(frac_err);
|
||
|
||
// aggregate all of the info into our info object, and update the data
|
||
// 11. 合并之前计算的数据，得到info，并更新bqsr table数据
|
||
ReadRecalInfo info(sd, readCovariates, skips, snpErrors, insErrors, delErrors);
|
||
|
||
PROF_START(update_info);
|
||
RecalUtils::updateRecalTablesForRead(info, recalTables);
|
||
PROF_END(gprof[GP_update_info], update_info);
|
||
}
|
||
readNumSum += readNum;
|
||
inBamBuf.ClearAll(); //
|
||
}
|
||
|
||
spdlog::info("read count: {}", readNumSum);
|
||
|
||
// 12. 创建总结数据
|
||
collapseQualityScoreTableToReadGroupTable(recalTables.readGroupTable, recalTables.qualityScoreTable);
|
||
roundTableValues(recalTables);
|
||
|
||
#if 0
|
||
printRecalTables(recalTables);
|
||
#endif
|
||
|
||
// 13. 量化质量分数
|
||
QuantizationInfo quantInfo(recalTables, nsgv::gBqsrArg.QUANTIZING_LEVELS);
|
||
|
||
// 14. 输出结果
|
||
RecalUtils::outputRecalibrationReport(nsgv::gBqsrArg, quantInfo, recalTables);
|
||
|
||
return 0;
|
||
}
|
||
|
||
// 多线程处理bam数据, tmd是乱序的？
|
||
static void thread_worker(void* data, long idx, int tid, int steal) {
|
||
// static void thread_worker(void* data, long idx, int tid) {
|
||
AuxVar& aux = (*(vector<AuxVar>*)data)[tid];
|
||
auto& readCovariates = aux.readCovariates;
|
||
RecalTables& recalTables = aux.recalTables;
|
||
SamData& sd = aux.sd;
|
||
StableArray<int>&isSNP = aux.isSNP, &isIns = aux.isIns, &isDel = aux.isDel; // 该位置是否是SNP, indel位置，0不是，1是
|
||
StableArray<uint8_t>& baqArray = aux.baqArray;
|
||
StableArray<double>&snpErrors = aux.snpErrors, &insErrors = aux.insErrors, &delErrors = aux.delErrors;
|
||
StableArray<uint8_t>& skips = aux.skips; // 该位置是否是已知位点
|
||
auto &bams = *aux.bamArr;
|
||
if (steal) for (auto& vcf : aux.vcfArr) vcf.knownSites.clear();
|
||
#if 1
|
||
int startIdx = idx * aux.BAM_BLOCK_NUM;
|
||
int stopIdx = std::min((size_t)(idx + 1) * aux.BAM_BLOCK_NUM, bams.size());
|
||
#else
|
||
int blockReadNums = (bams.size() + nsgv::gAuxVars.size() - 1) / nsgv::gAuxVars.size();
|
||
int startIdx = idx * blockReadNums;
|
||
int stopIdx = std::min((size_t)(idx + 1) * blockReadNums, bams.size());
|
||
#endif
|
||
aux.threadProcessedReads += stopIdx - startIdx;
|
||
for (int i = startIdx; i < stopIdx; ++i) {
|
||
// spdlog::info("Thread {} processing read idx: {}", tid, i);
|
||
BamWrap* bw = bams[i];
|
||
sd.init();
|
||
sd.parseBasic(bw);
|
||
sd.rid = i + aux.processedReads;
|
||
if (sd.read_len <= 0) continue;
|
||
|
||
//PROF_START(clip_read);
|
||
ReadTransformer::hardClipAdaptorSequence(bw, sd);
|
||
if (sd.read_len <= 0) continue;
|
||
ReadTransformer::hardClipSoftClippedBases(bw, sd);
|
||
if (sd.read_len <= 0) continue;
|
||
sd.applyTransformations();
|
||
// PROF_END(gprof[GP_clip_read], clip_read);
|
||
|
||
const int nErrors = RecalFuncs::calculateIsSNPOrIndel(aux, sd, isSNP, isIns, isDel);
|
||
|
||
bool baqCalculated = false;
|
||
if (nErrors == 0 || !nsgv::gBqsrArg.enableBAQ) {
|
||
baqCalculated = BAQ::flatBAQArray(sd, baqArray);
|
||
} else {
|
||
// baqCalculated = calculateBAQArray(nsgv::gAuxVars[0], baq, sd, baqArray);
|
||
}
|
||
if (!baqCalculated) continue;
|
||
|
||
// PROF_START(covariate);
|
||
CovariateUtils::ComputeCovariates(sd, aux.header, readCovariates, true);
|
||
// PROF_END(gprof[GP_covariate], covariate);
|
||
|
||
// PROF_START(read_vcf);
|
||
RecalFuncs::calculateKnownSites(sd, aux.vcfArr, aux.header, skips);
|
||
for (int ii = 0; ii < sd.read_len; ++ii) {
|
||
skips[ii] =
|
||
skips[ii] || (ContextCovariate::baseIndexMap[sd.bases[ii]] == -1) || sd.base_quals[ii] < nsgv::gBqsrArg.PRESERVE_QSCORES_LESS_THAN;
|
||
}
|
||
// PROF_GP_END(read_vcf);
|
||
#if 0
|
||
int fidx = 0 + 2 * tid;
|
||
//if (sd.rid % 2 == 0) fidx = 0 + 2 * tid;
|
||
//else fidx = 1 + 2 * tid;
|
||
fprintf(gf[fidx], "%ld %d\t", sd.rid, sd.read_len);
|
||
for (int ii = 0; ii < sd.read_len; ++ii) fprintf(gf[fidx], "%d ", skips[ii] ? 1 : 0);
|
||
fprintf(gf[fidx], "\n");
|
||
#endif
|
||
|
||
// PROF_START(frac_err);
|
||
RecalFuncs::calculateFractionalErrorArray(isSNP, baqArray, snpErrors);
|
||
RecalFuncs::calculateFractionalErrorArray(isIns, baqArray, insErrors);
|
||
RecalFuncs::calculateFractionalErrorArray(isDel, baqArray, delErrors);
|
||
// PROF_GP_END(frac_err);
|
||
|
||
ReadRecalInfo info(sd, readCovariates, skips, snpErrors, insErrors, delErrors);
|
||
|
||
//PROF_START(update_info);
|
||
RecalUtils::updateRecalTablesForRead(info, recalTables);
|
||
//PROF_END(gprof[GP_update_info], update_info);
|
||
}
|
||
}
|
||
|
||
// 并行bqsr
|
||
int ParallelBQSR(vector<AuxVar>& auxArr) {
|
||
BamBufType inBamBuf(nsgv::gBqsrArg.DUPLEX_IO);
|
||
inBamBuf.Init(nsgv::gInBamFp, nsgv::gInBamHeader, nsgv::gBqsrArg.MAX_MEM, bqsrReadFilterOut);
|
||
int64_t readNumSum = 0;
|
||
int round = 0;
|
||
|
||
while (true) {
|
||
++round;
|
||
// 一. 读取bam数据
|
||
size_t readNum = 0;
|
||
if (inBamBuf.ReadStat() >= 0) readNum = inBamBuf.ReadBam();
|
||
if (readNum < 1) { break; }
|
||
auto bams = inBamBuf.GetBamArr();
|
||
for_each(auxArr.begin(), auxArr.end(), [&](AuxVar& aux) {
|
||
aux.bamArr = &bams;
|
||
});
|
||
spdlog::info("{} reads processed in {} round", readNum, round);
|
||
|
||
#if 1
|
||
kt_for_steal(auxArr.size(), thread_worker, &auxArr, (readNum + AuxVar::BAM_BLOCK_NUM - 1) / AuxVar::BAM_BLOCK_NUM);
|
||
#else
|
||
kt_for_steal(auxArr.size(), thread_worker, &auxArr, auxArr.size());
|
||
#endif
|
||
readNumSum += readNum;
|
||
AuxVar::processedReads += readNum;
|
||
inBamBuf.ClearAll(); //
|
||
}
|
||
spdlog::info("read count: {}", readNumSum);
|
||
|
||
// 合并各个线程的结果
|
||
RecalTables& recalTables = auxArr[0].recalTables;
|
||
// printRecalTables(recalTables);
|
||
for (int i = 0; i < auxArr.size(); ++i)
|
||
spdlog::info("thread {} processed reads {}.", i, auxArr[i].threadProcessedReads);
|
||
for (int i = 1; i < auxArr.size(); ++i) {
|
||
auxArr[0].threadProcessedReads += auxArr[i].threadProcessedReads;
|
||
_Foreach3DK(auxArr[i].recalTables.qualityScoreTable, qualDatum, {
|
||
if (qualDatum.numObservations > 0) {
|
||
recalTables.qualityScoreTable(k1, k2, k3).increment(qualDatum);
|
||
}
|
||
});
|
||
_Foreach4DK(auxArr[i].recalTables.contextTable, contextDatum, {
|
||
if (contextDatum.numObservations > 0) {
|
||
recalTables.contextTable(k1, k2, k3, k4).increment(contextDatum);
|
||
}
|
||
});
|
||
_Foreach4DK(auxArr[i].recalTables.cycleTable, cycleDatum, {
|
||
if (cycleDatum.numObservations > 0) {
|
||
recalTables.cycleTable(k1, k2, k3, k4).increment(cycleDatum);
|
||
}
|
||
});
|
||
}
|
||
spdlog::info("All processed reads {}.", auxArr[0].threadProcessedReads);
|
||
|
||
// 创建总结数据
|
||
collapseQualityScoreTableToReadGroupTable(recalTables.readGroupTable, recalTables.qualityScoreTable);
|
||
roundTableValues(recalTables);
|
||
|
||
printRecalTables(recalTables);
|
||
|
||
// 量化质量分数
|
||
QuantizationInfo quantInfo(recalTables, nsgv::gBqsrArg.QUANTIZING_LEVELS);
|
||
|
||
// 输出结果
|
||
RecalUtils::outputRecalibrationReport(nsgv::gBqsrArg, quantInfo, recalTables);
|
||
|
||
return 0;
|
||
}
|
||
|
||
// 在进行数据处理之前，初始化一些全局数据
|
||
static void globalInit() {
|
||
open_debug_files();
|
||
/* bam */
|
||
nsgv::gInBamFp = sam_open_format(nsgv::gBqsrArg.INPUT_FILE.c_str(), "r", nullptr);
|
||
if (!nsgv::gInBamFp) {
|
||
spdlog::error("[{}] load sam/bam file failed.\n", __func__);
|
||
exit(1);
|
||
}
|
||
hts_set_opt(nsgv::gInBamFp, HTS_OPT_BLOCK_SIZE, BAM_BLOCK_SIZE);
|
||
nsgv::gInBamHeader = sam_hdr_read(nsgv::gInBamFp); // header
|
||
|
||
/* 并行读取bam数据 */
|
||
htsThreadPool htsPoolRead = {NULL, 0}; //
|
||
int readThreadNum = min(nsgv::gBqsrArg.NUM_THREADS, 8);
|
||
htsPoolRead.pool = hts_tpool_init(nsgv::gBqsrArg.NUM_THREADS);
|
||
if (!htsPoolRead.pool ) {
|
||
spdlog::error("[{}] failed to set up thread pool", __LINE__);
|
||
sam_close(nsgv::gInBamFp);
|
||
exit(1);
|
||
}
|
||
hts_set_opt(nsgv::gInBamFp, HTS_OPT_THREAD_POOL, &htsPoolRead);
|
||
|
||
if (!nsgv::gInBamHeader->hrecs) {
|
||
if (sam_hdr_fill_hrecs(nsgv::gInBamHeader) != 0) {
|
||
spdlog::error("[{}] failed to read sam header", __LINE__);
|
||
sam_close(nsgv::gInBamFp);
|
||
exit(1);
|
||
}
|
||
}
|
||
|
||
// 1. 协变量数据相关初始化
|
||
ContextCovariate::InitContextCovariate(nsgv::gBqsrArg);
|
||
CycleCovariate::InitCycleCovariate(nsgv::gBqsrArg);
|
||
|
||
// 注意初始化顺序，这个必须在协变量初始化之后，因为需要用到MaximumKeyValue
|
||
// nsgv::gRecalTables.init(nsgv::gInBamHeader->hrecs->nrg);
|
||
|
||
// 初始化AuxVar
|
||
nsgv::gAuxVars.resize(nsgv::gBqsrArg.NUM_THREADS);
|
||
for (int i = 0; i < nsgv::gBqsrArg.NUM_THREADS; ++i) {
|
||
nsgv::gAuxVars[i].header = nsgv::gInBamHeader;
|
||
nsgv::gAuxVars[i].faidx = fai_load(nsgv::gBqsrArg.REFERENCE_FILE.c_str());
|
||
if (nsgv::gAuxVars[i].faidx == 0)
|
||
error("[%s] fail to load the fasta index.\n", __func__);
|
||
for (auto& vcfFileName : nsgv::gBqsrArg.KNOWN_SITES_VCFS) {
|
||
nsgv::gAuxVars[i].vcfArr.push_back(VCFParser(vcfFileName, nsgv::gInBamHeader));
|
||
}
|
||
// 注意初始化顺序，这个必须在协变量初始化之后，因为需要用到MaximumKeyValue
|
||
nsgv::gAuxVars[i].recalTables.init(nsgv::gInBamHeader->hrecs->nrg);
|
||
CovariateUtils::InitPerReadCovMat(nsgv::gAuxVars[i].readCovariates);
|
||
}
|
||
|
||
// 0. 初始化一些全局数据
|
||
// BAQ baq{BAQ::DEFAULT_GOP};
|
||
BAQ::StaticInit();
|
||
RecalDatum::StaticInit();
|
||
QualityUtils::StaticInit();
|
||
MathUtils::StaticInit();
|
||
BaseUtils::StaticInit();
|
||
|
||
// 初始化需要计算的event types
|
||
RecalUtils::initEventTypes(nsgv::gBqsrArg.computeIndelBQSRTables);
|
||
|
||
// 2. 读取bam的read group
|
||
if (nsgv::gInBamHeader->hrecs->nrg == 0) {
|
||
spdlog::error("No RG tag found in the header!");
|
||
exit(1);
|
||
}
|
||
for (int i = 0; i < nsgv::gInBamHeader->hrecs->nrg; ++i) {
|
||
// spdlog::info("rg: {}", nsgv::gInBamHeader->hrecs->rg[i].name);
|
||
ReadGroupCovariate::RgToId[nsgv::gInBamHeader->hrecs->rg[i].name] = i;
|
||
ReadGroupCovariate::IdToRg[i] = nsgv::gInBamHeader->hrecs->rg[i].name;
|
||
}
|
||
}
|
||
|
||
// 全局资源释放
|
||
static void globalDestroy() {
|
||
close_debug_files();
|
||
}
|
||
|
||
// entrance of mark BQSR
|
||
int BaseRecalibrator() {
|
||
int ret = 0;
|
||
|
||
PROF_START(whole_process);
|
||
globalInit();
|
||
if (nsgv::gBqsrArg.NUM_THREADS == 1)
|
||
ret = SerialBQSR(nsgv::gAuxVars[0]); // 串行处理数据，生成recal table
|
||
else
|
||
ret = ParallelBQSR(nsgv::gAuxVars); // 并行处理数据，生成recal table
|
||
globalDestroy();
|
||
sam_close(nsgv::gInBamFp);
|
||
PROF_END(gprof[GP_whole_process], whole_process);
|
||
|
||
return ret;
|
||
}
|