// returns BAM file pointers to beginning of alignment data
bool BamMultiReaderPrivate::RewindReaders()
{
m_errorString.clear();
bool errorsEncountered = false;
// iterate over readers
std::vector<MergeItem>::iterator readerIter = m_readers.begin();
std::vector<MergeItem>::iterator readerEnd = m_readers.end();
for (; readerIter != readerEnd; ++readerIter) {
MergeItem& item = (*readerIter);
BamReader* reader = item.Reader;
if (reader == 0) continue;
// attempt rewind on BamReader
if (!reader->Rewind()) {
m_errorString.append(1, '\t');
m_errorString.append(reader->GetErrorString());
m_errorString.append(1, '\n');
errorsEncountered = true;
}
}
return !errorsEncountered;
}
// locate (& load) index files for BAM readers that don't already have one loaded
bool BamMultiReaderPrivate::LocateIndexes(const BamIndex::IndexType& preferredType)
{
bool errorsEncountered = false;
m_errorString.clear();
// iterate over readers
std::vector<MergeItem>::iterator readerIter = m_readers.begin();
std::vector<MergeItem>::iterator readerEnd = m_readers.end();
for (; readerIter != readerEnd; ++readerIter) {
MergeItem& item = (*readerIter);
BamReader* reader = item.Reader;
if (reader == 0) continue;
// if reader has no index, try to locate one
if (!reader->HasIndex()) {
if (!reader->LocateIndex(preferredType)) {
m_errorString.append(1, '\t');
m_errorString.append(reader->GetErrorString());
m_errorString.append(1, '\n');
errorsEncountered = true;
}
}
}
// check for errors encountered before returning success/fail
if (errorsEncountered) {
const std::string currentError = m_errorString;
const std::string message =
std::string("error while locating index files: \n") + currentError;
SetErrorString("BamMultiReader::LocatingIndexes", message);
return false;
} else
return true;
}
// creates index files for BAM files that don't have them
bool BamMultiReaderPrivate::CreateIndexes(const BamIndex::IndexType& type) {
bool errorsEncountered = false;
m_errorString.clear();
// iterate over readers
vector<MergeItem>::iterator itemIter = m_readers.begin();
vector<MergeItem>::iterator itemEnd = m_readers.end();
for ( ; itemIter != itemEnd; ++itemIter ) {
MergeItem& item = (*itemIter);
BamReader* reader = item.Reader;
if ( reader == 0 ) continue;
// if reader doesn't have an index, create one
if ( !reader->HasIndex() ) {
if ( !reader->CreateIndex(type) ) {
m_errorString.append(1, '\t');
m_errorString.append(reader->GetErrorString());
m_errorString.append(1, '\n');
errorsEncountered = true;
}
}
}
// check for errors encountered before returning success/fail
if ( errorsEncountered ) {
const string currentError = m_errorString;
const string message = string("error while creating index files: ") + "\n" + currentError;
SetErrorString("BamMultiReader::CreateIndexes", message);
return false;
} else
return true;
}
bool BamMultiReaderPrivate::OpenIndexes(const std::vector<std::string>& indexFilenames)
{
// TODO: This needs to be cleaner - should not assume same order.
// And either way, shouldn't start at first reader. Should start at
// first reader without an index?
// make sure same number of index filenames as readers
if (m_readers.size() != indexFilenames.size()) {
const std::string message("size of index file list does not match current BAM file count");
SetErrorString("BamMultiReader::OpenIndexes", message);
return false;
}
bool errorsEncountered = false;
m_errorString.clear();
// iterate over BamReaders
std::vector<std::string>::const_iterator indexFilenameIter = indexFilenames.begin();
std::vector<std::string>::const_iterator indexFilenameEnd = indexFilenames.end();
std::vector<MergeItem>::iterator readerIter = m_readers.begin();
std::vector<MergeItem>::iterator readerEnd = m_readers.end();
for (; readerIter != readerEnd; ++readerIter) {
MergeItem& item = (*readerIter);
BamReader* reader = item.Reader;
// open index filename on reader
if (reader) {
const std::string& indexFilename = (*indexFilenameIter);
if (!reader->OpenIndex(indexFilename)) {
m_errorString.append(1, '\t');
m_errorString += reader->GetErrorString();
m_errorString.append(1, '\n');
errorsEncountered = true;
}
}
// increment filename iterator, skip if no more index files to open
if (++indexFilenameIter == indexFilenameEnd) break;
}
// return success/fail
if (errorsEncountered) {
const std::string currentError = m_errorString;
const std::string message =
std::string("could not open all index files: \n\t") + currentError;
SetErrorString("BamMultiReader::OpenIndexes", message);
return false;
} else
return true;
}
// open BAM input file
void BAMWalkerEngine::InitializeBAMs(const ReferenceReader& ref_reader, const vector<string>& bam_filenames)
{
if (not bam_reader_.SetExplicitMergeOrder(BamMultiReader::MergeByCoordinate)) {
cerr << "ERROR: Could not set merge order to BamMultiReader::MergeByCoordinate" << endl;
exit(1);
}
if (not bam_reader_.Open(bam_filenames)) {
cerr << "ERROR: Could not open input BAM file(s) : " << bam_reader_.GetErrorString() << endl;
exit(1);
}
if (not bam_reader_.LocateIndexes()) {
cerr << "ERROR: Could not open BAM index file(s) : " << bam_reader_.GetErrorString() << endl;
exit(1);
}
// BAM multi reader combines the read group information of the different BAMs but does not merge comment sections
bam_header_ = bam_reader_.GetHeader();
if (!bam_header_.HasReadGroups()) {
cerr << "ERROR: there is no read group in BAM files specified" << endl;
exit(1);
}
// Manually merge comment sections of BAM files if we have more than one BAM file
if (bam_filenames.size() > 1) {
unsigned int num_duplicates = 0;
unsigned int num_merged = 0;
for (unsigned int bam_idx = 0; bam_idx < bam_filenames.size(); bam_idx++) {
BamReader reader;
if (not reader.Open(bam_filenames.at(bam_idx))) {
cerr << "TVC ERROR: Failed to open input BAM file " << reader.GetErrorString() << endl;
exit(1);
}
SamHeader header = reader.GetHeader();
for (unsigned int i_co = 0; i_co < header.Comments.size(); i_co++) {
// Step 1: Check if this comment is already part of the merged header
unsigned int m_co = 0;
while (m_co < bam_header_.Comments.size() and bam_header_.Comments.at(m_co) != header.Comments.at(i_co))
m_co++;
if (m_co < bam_header_.Comments.size()){
num_duplicates++;
continue;
}
// Add comment line to merged header if it is a new one
num_merged++;
bam_header_.Comments.push_back(header.Comments.at(i_co));
}
}
// Verbose what we did
cout << "Merged " << num_merged << " unique comment lines into combined BAM header. Encountered " << num_duplicates << " duplicate comments." << endl;
}
//
// Reference sequences in the bam file must match that in the fasta file
//
vector<RefData> referenceSequences = bam_reader_.GetReferenceData();
if ((int)referenceSequences.size() != ref_reader.chr_count()) {
cerr << "ERROR: Reference in BAM file does not match fasta file" << endl
<< " BAM has " << referenceSequences.size()
<< " chromosomes while fasta has " << ref_reader.chr_count() << endl;
exit(1);
}
for (int chr_idx = 0; chr_idx < ref_reader.chr_count(); ++chr_idx) {
if (referenceSequences[chr_idx].RefName != ref_reader.chr_str(chr_idx)) {
cerr << "ERROR: Reference in BAM file does not match fasta file" << endl
<< " Chromosome #" << (chr_idx+1) << "in BAM is " << referenceSequences[chr_idx].RefName
<< " while fasta has " << ref_reader.chr_str(chr_idx) << endl;
exit(1);
}
if (referenceSequences[chr_idx].RefLength != ref_reader.chr_size(chr_idx)) {
cerr << "ERROR: Reference in BAM file does not match fasta file" << endl
<< " Chromosome " << referenceSequences[chr_idx].RefName
<< "in BAM has length " << referenceSequences[chr_idx].RefLength
<< " while fasta has " << ref_reader.chr_size(chr_idx) << endl;
exit(1);
}
}
//
// Retrieve BaseCaller and TMAP version strings from BAM header
//
set<string> basecaller_versions;
set<string> tmap_versions;
for (SamProgramIterator I = bam_header_.Programs.Begin(); I != bam_header_.Programs.End(); ++I) {
if (I->ID.substr(0,2) == "bc")
basecaller_versions.insert(I->Version);
if (I->ID.substr(0,4) == "tmap")
tmap_versions.insert(I->Version);
}
basecaller_version_ = "";
for (set<string>::const_iterator I = basecaller_versions.begin(); I != basecaller_versions.end(); ++I) {
if (not basecaller_version_.empty())
basecaller_version_ += ", ";
basecaller_version_ += *I;
}
tmap_version_ = "";
for (set<string>::const_iterator I = tmap_versions.begin(); I != tmap_versions.end(); ++I) {
if (not tmap_version_.empty())
tmap_version_ += ", ";
tmap_version_ += *I;
}
}
int main (int argc, char** argv)
{
// Print Commandline
string ss(argv[0]); // convert Char to String
string commandline = "##Print Command line " + ss;
int c;
FastaReference* reference = NULL;
int minbaseQ = 10; //default
int windowlen = 40; //by default
string regionstr;
string RegionFile;
string bamfile;
bool STdin = false;
bool has_region = false;
bool has_regionFile = false;
bool has_bamfile = false;
bool has_ref = false;
int ploidy = 2;
bool SetLowComplexityRegionSWGapExt = false;
bool SetLowComplexityRegion = false;
if (argc < 2)
{
printSummary(argv);
exit(1);
}
while (true)
{
static struct option long_options[] =
{
{"help", no_argument, 0, 'h'},
{"ploidy", required_argument, 0, 'p'},
{"window-size", required_argument, 0, 'w'},
{"reference", required_argument, 0, 'f'},
{"min-base-quality", required_argument, 0,'q'},
{"Region", required_argument, 0, 'R'},
{"STdin", no_argument, 0, 's'},
{"bam", required_argument, 0, 'b'},
{"Repeat-Extgap", no_argument, 0, 'E'},
{"LowCompex", no_argument, 0, 'l'},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long (argc, argv, "hslEf:q:w:s:r:R:p:b:", long_options, &option_index);
/* Detect the end of the options. */
if (c == -1)
break;
switch (c)
{
case 'f':
reference = new FastaReference(optarg); // will exit on open failure
commandline = commandline + " -f " + optarg;
has_ref = true;
break;
case 'b':
has_bamfile = true;
bamfile = optarg;
commandline = commandline + " -b " + optarg;
break;
case 'r':
regionstr = optarg;
has_region = true;
commandline = commandline + " -r " + optarg;
break;
case 'R':
RegionFile = optarg;
has_regionFile = true;
commandline = commandline + " -R " + optarg;
break;
case 's':
STdin = true;
commandline = commandline + " -s ";
break;
case 'q':
minbaseQ = atoi(optarg);
commandline = commandline + " -q " + optarg;
break;
case 'w':
windowlen = atoi(optarg);
commandline = commandline + " -w " + optarg;
break;
case 'p':
ploidy = atoi(optarg);
commandline = commandline + " -p " + optarg;
break;
case 'E':
SetLowComplexityRegionSWGapExt = true;
commandline = commandline + " -E ";
break;
case 'l':
SetLowComplexityRegion = true;
commandline = commandline + " -l ";
break;
case 'h':
printSummary(argv);
commandline = commandline + " -h ";
exit(0);
break;
case '?':
printSummary(argv);
exit(1);
break;
default:
abort();
break;
}
}
//// Open Error log files
ofstream cerrlog("bonsaiReport.txt");
streambuf *cerrsave = std::cerr.rdbuf();
// Redirect stream buffers
if (cerrlog.is_open())
cerr.rdbuf(cerrlog.rdbuf());
cerr << commandline << endl;
//Check for Reference Fasta sequence
if (!has_ref)
{
cerr << "no FASTA reference provided, cannot realign" << endl;
exit(1);
}
////Check for reader
BamReader reader;
if (STdin == true)
{
if (!reader.Open("stdin"))
{
cerr << "could not open stdin bam for reading" << endl;
cerr << reader.GetErrorString() << endl;
reader.Close();
printSummary(argv);
}
}
else
{
if (has_bamfile == true)
{
if (!reader.Open(bamfile))
{
cerr << "ERROR: could not open bam files from stdin ... Aborting" << endl;
cerr << reader.GetErrorString() << endl;
reader.Close();
printSummary(argv);
}
if ( !reader.LocateIndex() )
reader.CreateIndex();
}
else
{
cerr << "--bam flag is set but no bamfile is provided... Aborting" << endl;
reader.Close();
printSummary(argv);
}
}
//// Check Region Tags
if ( (has_regionFile == true) && (has_region == true) )
{
cerr << "ERROR: You provide both region and has provide a Set Region List... Aborting" << endl;
exit(1);
}
//// store the names of all the reference sequences in the BAM file
vector<RefData> referencedata = reader.GetReferenceData();
//// Store Region LIST
vector<BamRegion> regionlist;
if (has_region == true)
{
BamRegion region;
ParseRegionString(regionstr, reader, region);
regionlist.push_back(region);
}
else if (has_regionFile == true)
{
ifstream RG(RegionFile.c_str(), ios_base::in);
string line;
while(getline(RG,line))
{
BamRegion region;
ParseRegionString(line, reader, region);
regionlist.push_back(region);
}
RG.close();
}
else if ( (has_regionFile == false) && (has_region == false) )
{
for (int i= 0; i < (int)referencedata.size(); i++)
{
string regionstr = referencedata.at(i).RefName;
BamRegion region;
ParseRegionString(regionstr, reader, region);
if (!reader.SetRegion(region)) // Bam region will get [0,101) = 0 to 100 => [closed, half-opened)
{
cerr << "ERROR: set region " << regionstr << " failed. Check that REGION describes a valid range... Aborting" << endl;
reader.Close();
exit(1);
}
else
regionlist.push_back(region);
}
}
////
BamWriter writer;
if (!writer.Open("stdout", reader.GetHeaderText(), reader.GetReferenceData()))
{
cerr << "could not open stdout for writing" << endl;
exit(1);
}
//// Smallest start position and Largest end position for Req Seq
vector<RefData>::iterator refdataIter = referencedata.begin();
vector<BamRegion>::iterator regionListIter = regionlist.begin();
// CLASS
RealignFunctionsClass RealignFunction;
map<int, string> RefIDRedName;
vector<SalRealignInfo> AlGroups;
multimap<int, BamAlignment> SortRealignedAlignmentsMultimap;
int refid = 0;
BamAlignment alignment;
bool IsNextAlignment = reader.GetNextAlignment(alignment);
//cerr << " " << alignment.Name << " Chr " << alignment.RefID << " Startpos: " << alignment.Position << " Endpos: " << alignment.GetEndPosition() << " Length: " << alignment.Length << endl;
int windowrealigned = 0;
int TotalWindowDetected = 0;
int TotalReadsAligned = 0;
int TotalWindow = 0;
int TotalReads = 0;
while (refdataIter != referencedata.end() )
{
string refname = refdataIter->RefName;
RefIDRedName[refid] = refname;
int reflength = refdataIter->RefLength;
int winstartpos, winendpos;
int AllowableBasesInWindow = 1;
bool nextChrName = false;
cerr << "##HeaderINFO: RefID = " << refdataIter->RefName << "\t" << "RefLen = " << reflength << endl;
while (nextChrName == false )
{
vector<int> minmaxRefSeqPos;
bool IsPassDetectorNoRealignment = false;
minmaxRefSeqPos.push_back(-1);
minmaxRefSeqPos.push_back(0);
//cerr << " region: " << (*regionListIter).LeftRefID << " : " << (*regionListIter).LeftPosition << " .. " << (*regionListIter).RightPosition << endl;
if ((refid == (int)referencedata.size() - 1) && ((*regionListIter).LeftRefID == refid) && ((has_region==true) || (has_regionFile==true)) )
{
////
if ( (has_region == true) || (has_regionFile == true) )
{
winstartpos = (*regionListIter).LeftPosition;
winendpos = winstartpos + windowlen - 1;
reflength = (*regionListIter).RightPosition;
if (reflength < winendpos)
reflength = winendpos;
// Get Next Alignment First
if ( (refid == alignment.RefID) && (winstartpos == (*regionListIter).LeftPosition) && (IsNextAlignment == false) )
IsNextAlignment = reader.GetNextAlignment(alignment);
}
else if (has_region == false)
{
winstartpos = 0;
winendpos = winstartpos + windowlen - 1;
// Get Next Alignment First
if ( (refid == alignment.RefID) && (winstartpos == 0) && (IsNextAlignment == false) )
IsNextAlignment = reader.GetNextAlignment(alignment);
}
//cerr << " winstart: " << winstartpos << " ; winend: " << winendpos;
//cerr << " " << alignment.Name << " Chr " << alignment.RefID << " Startpos: " << alignment.Position << " Endpos: " << alignment.GetEndPosition() << " Length: " << alignment.Length << endl;
////
while ((winstartpos < reflength))
{
//// Check window end position
if (winendpos > reflength)
winendpos = reflength;
// Reinitialized
unsigned int NewReadMappedcount = 0;
//// Save and Erase alignments that are outside of window (Deque?)
if (!AlGroups.empty())
{
minmaxRefSeqPos.at(0) = -1;
minmaxRefSeqPos.at(1) = 0;
//cerr << "#Start: Keep alignments with start position exceed the right end of the window/Region " << endl;
vector<SalRealignInfo>::iterator Iter = AlGroups.begin();
while (Iter != AlGroups.end())
{
// Erase alignment s
if ((*Iter).al.GetEndPosition() < winstartpos)
{
//cerr << " ToWrite: " << (*Iter).second.size() << " ; " << (*Iter).al.Name << " ; " << (*Iter).al.Position << " < " << winstartpos << " : " << (*Iter).al.GetEndPosition() << endl;
SortRealignedAlignmentsMultimap.insert(pair<int, BamAlignment > ((*Iter).al.Position, (*Iter).al));
AlGroups.erase(Iter);
//cerr << " ToWrite: DONE " << endl;
}
else
{
string referenceSequence = reference->getSubSequence(RefIDRedName[(*Iter).al.RefID], (*Iter).al.Position, 2*(*Iter).al.Length);
if ((*Iter).HasRealign == true )
{
(*Iter).currentReadPosition = 0;
(*Iter).currentGenomeSeqPosition = 0;
(*Iter).currentAlPosition = (*Iter).al.Position;
(*Iter).cigarindex = 0;
}
(*Iter).CigarSoftclippingLength = 0;
SalRealignInfo talr = (*Iter);
//cerr << " ToKEEP: " << (*Iter).al.Name << " ; " << (*Iter).al.Position << " < " << winstartpos << " : " << (*Iter).al.GetEndPosition() << endl;
RealignFunction.ParseAlignmentsAndExtractVariantsByBaseQualv(AlGroups, talr, Iter, (*Iter).al, referenceSequence, minmaxRefSeqPos, winstartpos, winendpos, (float) minbaseQ, false);
++Iter; //Increment iterator
}
}
}
// Write Sorted Alignments that are outside of window
//cerr << "SortRealignedAlignmentsMultimap: " << SortRealignedAlignmentsMultimap.size() << " minmaxRefSeqPos.at(0)= " << minmaxRefSeqPos.at(0) << endl;
if (!SortRealignedAlignmentsMultimap.empty()) // && (winWrite < winstartpos ) )
{
//cerr << "#Start: Write alignments and delete alignments with start position exceed the right end of the window/Region " << endl;
multimap<int, BamAlignment>::iterator sraIter = SortRealignedAlignmentsMultimap.begin();
while (sraIter != SortRealignedAlignmentsMultimap.end())
{
//cerr << " (*sraIter).first= " << (*sraIter).first << " minmaxRefSeqPos.at(0)= " << minmaxRefSeqPos.at(0) << " winstartpos - ((windowlen - 1)*0.9)= " << winstartpos - ((windowlen - 1)*0.9) << endl;
if (((float) (*sraIter).first < floor((float) (winstartpos - ((windowlen - 1)*0.9)))) && ((minmaxRefSeqPos.at(0) > 0) && ((*sraIter).first < minmaxRefSeqPos.at(0)))) {
//writer.SaveAlignment((*sraIter).second); // Why sometimes, it doesn't work ?????
if (!writer.SaveAlignment((*sraIter).second))
cerr << writer.GetErrorString() << endl;
SortRealignedAlignmentsMultimap.erase(sraIter++);
} else {
++sraIter;
}
}
//cerr << "#Done: Write alignments and delete alignments with start position exceed the right end of the window/Region " << endl;
}
//cerr << " winstart: " << winstartpos << " ; winend: " << winendpos;
//cerr << " " << alignment.Name << " Chr " << alignment.RefID << " Startpos: " << alignment.Position << " Endpos: " << alignment.GetEndPosition() << " Length: " << alignment.Length << endl;
//cerr << ": " << alignment.RefID << " :" << RefIDRedName[alignment.RefID] << " : " << RefIDRedName[alignment.RefID] << endl;
//cerr << "Start: Gather aligmenets that lie (fully or partially) within the window frame and group INDELs if there are ... " << endl;
// Gather Reads within a window frame
while ((IsNextAlignment) && (refid == alignment.RefID)) // Neeed more conditions
{
if (SetLowComplexityRegion == true)
{
string sequenceInWindow = reference->getSubSequence(RefIDRedName[alignment.RefID], winstartpos, (winendpos-winstartpos+1) );
if (IsWindowInRepeatRegion(sequenceInWindow) == true)
{
if ((IsWithinWindow(alignment, winstartpos, winendpos, AllowableBasesInWindow)) == 0)
{
TotalReads++;
if (alignment.IsMapped())
{
string referenceSequence = reference->getSubSequence(RefIDRedName[alignment.RefID], alignment.Position, 2*alignment.Length);
vector<SalRealignInfo>::iterator tIter;
SalRealignInfo alr;
alr.al = alignment;
alr.currentReadPosition = 0;
alr.currentGenomeSeqPosition = 0;
alr.currentAlPosition = alignment.Position;
alr.cigarindex = 0;
alr.HasRealign = false;
alr.CigarSoftclippingLength = 0;
string str = "ZZZZZZZZZZZZZZZZZ";
if (alignment.Name.find(str) != string::npos) {
stringstream cigar;
for (vector<CigarOp>::const_iterator cigarIter = alignment.CigarData.begin(); cigarIter != alignment.CigarData.end(); ++cigarIter)
cigar << cigarIter->Length << cigarIter->Type;
string cigarstr = cigar.str();
cerr << " TRACKING: " << alignment.RefID << " " << alignment.Name << " pos: " << alignment.Position << " cigar: " << cigarstr << endl;
}
RealignFunction.ParseAlignmentsAndExtractVariantsByBaseQualv(AlGroups, alr, tIter, alignment, referenceSequence, minmaxRefSeqPos, winstartpos, winendpos, (float) minbaseQ, true);
NewReadMappedcount++;
}
else
{
SortRealignedAlignmentsMultimap.insert(pair<int, BamAlignment > (alignment.Position, alignment));
cerr << "UNmapped : " << alignment.Name << endl;
}
}
else if ((IsWithinWindow(alignment, winstartpos, winendpos, AllowableBasesInWindow)) == 1)
{
SortRealignedAlignmentsMultimap.insert(pair<int, BamAlignment > (alignment.Position, alignment));
}
else
break;
} else {
if ((IsWithinWindow(alignment, winstartpos, winendpos, AllowableBasesInWindow)) < 2)
SortRealignedAlignmentsMultimap.insert(pair<int, BamAlignment > (alignment.Position, alignment));
else
break;
}
}
else // (SetLowComplexityRegion == false)
{
if ((IsWithinWindow(alignment, winstartpos, winendpos, AllowableBasesInWindow)) == 0)
{
TotalReads++;
if (alignment.IsMapped())
{
string referenceSequence = reference->getSubSequence(RefIDRedName[alignment.RefID], alignment.Position, 2 * alignment.Length);
vector<SalRealignInfo>::iterator tIter;
SalRealignInfo alr;
alr.al = alignment;
alr.currentReadPosition = 0;
alr.currentGenomeSeqPosition = 0;
alr.currentAlPosition = alignment.Position;
alr.cigarindex = 0;
alr.HasRealign = false;
alr.CigarSoftclippingLength = 0;
string str = "ZZZZZZZZZZZZZZZZZ";
if (alignment.Name.find(str) != string::npos)
{
stringstream cigar;
for (vector<CigarOp>::const_iterator cigarIter = alignment.CigarData.begin(); cigarIter != alignment.CigarData.end(); ++cigarIter)
cigar << cigarIter->Length << cigarIter->Type;
string cigarstr = cigar.str();
cerr << " TRACKING: " << alignment.RefID << " " << alignment.Name << " pos: " << alignment.Position << " cigar: " << cigarstr << endl;
}
RealignFunction.ParseAlignmentsAndExtractVariantsByBaseQualv(AlGroups, alr, tIter, alignment, referenceSequence, minmaxRefSeqPos, winstartpos, winendpos, (float) minbaseQ, true);
//cerr << " winstart: " << winstartpos << " ; winend: " << winendpos;
//cerr << " INDEL: " << alignment.RefID << " " << alignment.Name << " pos: " << alignment.Position << " Length: " << alignment.Length << " CIGARstr: " << cigarstr << endl;
NewReadMappedcount++;
}
else
{
SortRealignedAlignmentsMultimap.insert(pair<int, BamAlignment > (alignment.Position, alignment));
cerr << "UNmapped : " << alignment.Name << endl;
}
}
else if ((IsWithinWindow(alignment, winstartpos, winendpos, AllowableBasesInWindow)) == 1) {
SortRealignedAlignmentsMultimap.insert(pair<int, BamAlignment > (alignment.Position, alignment));
}
else
break;
}
////Get next alignment
IsNextAlignment = reader.GetNextAlignment(alignment);
}
//cerr << "Done: Gather aligmenets that lie (fully or partially) within the window frame and group INDELs if there are ... " << endl;
//// Detector Corner
bool ToRealign = MeetIndelDetectorThresholdv(AlGroups);
cerr << "MeetIndelDetectorThresholdv(AlGroups).size()= " << AlGroups.size() << endl;
// **************
if (ToRealign)
{
//cerr << " ToRealign: " << refdataIter->RefName << "\t" << reflength << "\t" << winstartpos << "\t" << winendpos << "\t" << AlGroups.size() << endl;
//cerr << " minmaxRefSeqPos.at(1)= " << minmaxRefSeqPos.at(1) << " minmaxRefSeqPos.at(0)= " << minmaxRefSeqPos.at(0) << endl;
////// Perform Realign routines
int TotalAlR = 0; // Total number of alignments to be realigned
int NumAlR = 0; // Now many alignments are aligned
TotalWindowDetected++;
cerr << "#Start: Meet Threshold, Realigning ... " << endl;
if (minmaxRefSeqPos.at(1) < winendpos)
minmaxRefSeqPos.at(1) = winendpos;
if (minmaxRefSeqPos.at(0) > winstartpos)
minmaxRefSeqPos.at(0) = winstartpos;
bool IsToRealign = RealignFunction.PruningByNaiveSelectionProcedureAndConstructHaplotypes2(winstartpos, winendpos, refid, refname, minmaxRefSeqPos, reference);
if (IsToRealign == true)
{
RealignFunction.SelectHaplotypeCandidates_SmithWatermanBSv(AlGroups, minmaxRefSeqPos, SetLowComplexityRegionSWGapExt);
minmaxRefSeqPos.at(0) = -1;
minmaxRefSeqPos.at(1) = 0;
int nextwinstartpos = winendpos + 1;
int nextwinendpos = winstartpos + windowlen - 1;
if (nextwinendpos > reflength)
nextwinendpos = reflength;
//cerr << " Before Realign : " << SortRealignedAlignmentsMultimap.size() << endl;
RealignFunction.AdjustCigarsWRTChosenMultipleHaplotypesAndPrepareAlignmentsTobeWrittenOut(AlGroups, SortRealignedAlignmentsMultimap, reference, RefIDRedName, minmaxRefSeqPos, nextwinstartpos, nextwinendpos, minbaseQ, TotalAlR, NumAlR, ploidy);
IsPassDetectorNoRealignment = false; // Set flag to false to deactivate write functions
//cerr << " After Realign : " << SortRealignedAlignmentsMultimap.size() << endl;
TotalReadsAligned += NumAlR;
if (NumAlR > 0) // Realignment done
windowrealigned++;
} else
cerr << "#Done: Meet Threshold, Realigning ... " << endl;
}
if (NewReadMappedcount > 0)
TotalWindow++;
RealignFunction.Clear();
//// Move the window frame
winstartpos = winendpos + 1;
winendpos = winstartpos + windowlen - 1;
}
//// Save and Erase remaining alignments that are outside of window (Deque?)
if ((!AlGroups.empty())) {
cerr << "#Start: Write Remaining alignments and delete all alignments" << endl;
for (vector<SalRealignInfo>::iterator Iter = AlGroups.begin(); Iter != AlGroups.end(); ++Iter) {
//cerr << " Remain alignment start: " << (*Iter).al.Name << " " << Iter->al.Position << " < " << winstartpos << " " << winendpos << endl;
SortRealignedAlignmentsMultimap.insert(pair<int, BamAlignment > ((*Iter).al.Position, (*Iter).al));
}
cerr << "#Done: Write Remaining alignments and delete all alignments" << endl;
}
AlGroups.clear();
// Write Sorted remaining Alignments that are outside of window
if (!SortRealignedAlignmentsMultimap.empty())
{
for (multimap<int, BamAlignment>::iterator sraIter = SortRealignedAlignmentsMultimap.begin(); sraIter != SortRealignedAlignmentsMultimap.end(); ++sraIter)
{
//writer.SaveAlignment((*sraIter).second);
if (!writer.SaveAlignment((*sraIter).second))
cerr << writer.GetErrorString() << endl;
}
SortRealignedAlignmentsMultimap.clear();
}
}
++regionListIter;
if ((*regionListIter).LeftRefID > refid)
nextChrName = true;
}
//// If End of the chromosome position
//// increament iterator
++refdataIter;
++refid;
}
reader.Close();
writer.Close();
cerr << "##-Completed- " << endl;
cerr << " Total Reads processed = " << TotalReads << endl;
cerr << " Total Reads Aligned = " << TotalReadsAligned << endl;
cerr << " Total Window processed = " << TotalWindow << endl;
cerr << " Total Window Detected = " << TotalWindowDetected << endl;
cerr << " Total Windows Aligned = " << windowrealigned << endl;
// Restore cerr's stream buffer before terminating
if (cerrlog.is_open())
cerr.rdbuf(cerrsave);
commandline.clear();
return 0;
}
// close requested BAM files
bool BamMultiReaderPrivate::CloseFiles(const std::vector<std::string>& filenames)
{
bool errorsEncountered = false;
m_errorString.clear();
// iterate over filenames
std::vector<std::string>::const_iterator filesIter = filenames.begin();
std::vector<std::string>::const_iterator filesEnd = filenames.end();
for (; filesIter != filesEnd; ++filesIter) {
const std::string& filename = (*filesIter);
if (filename.empty()) continue;
// iterate over readers
std::vector<MergeItem>::iterator readerIter = m_readers.begin();
std::vector<MergeItem>::iterator readerEnd = m_readers.end();
for (; readerIter != readerEnd; ++readerIter) {
MergeItem& item = (*readerIter);
BamReader* reader = item.Reader;
if (reader == 0) continue;
// if reader matches requested filename
if (reader->GetFilename() == filename) {
// remove reader's entry from alignment cache
m_alignmentCache->Remove(reader);
// clean up reader & its alignment
if (!reader->Close()) {
m_errorString.append(1, '\t');
m_errorString.append(reader->GetErrorString());
m_errorString.append(1, '\n');
errorsEncountered = true;
}
delete reader;
reader = 0;
// delete reader's alignment entry
BamAlignment* alignment = item.Alignment;
delete alignment;
alignment = 0;
// remove reader from reader list
m_readers.erase(readerIter);
// on match, just go on to next filename
// (no need to keep looking and item iterator is invalid now anyway)
break;
}
}
}
// make sure we clean up properly if all readers were closed
if (m_readers.empty()) {
// clean up merger
if (m_alignmentCache) {
m_alignmentCache->Clear();
delete m_alignmentCache;
m_alignmentCache = 0;
}
// reset merge flags
m_hasUserMergeOrder = false;
m_mergeOrder = BamMultiReader::RoundRobinMerge;
}
// return whether all readers closed OK
return !errorsEncountered;
}
