// opens BAM files
bool BamMultiReader::Open(const vector<string> filenames, bool openIndexes, bool coreMode, bool useDefaultIndex) {
// for filename in filenames
fileNames = filenames; // save filenames in our multireader
for (vector<string>::const_iterator it = filenames.begin(); it != filenames.end(); ++it) {
string filename = *it;
BamReader* reader = new BamReader;
bool openedOK = true;
if (openIndexes) {
if (useDefaultIndex)
openedOK = reader->Open(filename, filename + ".bai");
else
openedOK = reader->Open(filename, filename + ".bti");
} else {
openedOK = reader->Open(filename); // for merging, jumping is disallowed
}
// if file opened ok, check that it can be read
if ( openedOK ) {
bool fileOK = true;
BamAlignment* alignment = new BamAlignment;
if (coreMode) {
fileOK &= reader->GetNextAlignmentCore(*alignment);
} else {
fileOK &= reader->GetNextAlignment(*alignment);
}
if (fileOK) {
readers.push_back(make_pair(reader, alignment)); // store pointers to our readers for cleanup
alignments.insert(make_pair(make_pair(alignment->RefID, alignment->Position),
make_pair(reader, alignment)));
} else {
cerr << "WARNING: could not read first alignment in " << filename << ", ignoring file" << endl;
// if only file available & could not be read, return failure
if ( filenames.size() == 1 ) return false;
}
}
// TODO; any more error handling on openedOK ??
else
return false;
}
// files opened ok, at least one alignment could be read,
// now need to check that all files use same reference data
ValidateReaders();
return true;
}
void BamToFastq::SingleFastq() {
// open the 1st fastq file for writing
ofstream fq(_fastq1.c_str(), ios::out);
if ( !fq ) {
cerr << "Error: The first fastq file (" << _fastq1 << ") could not be opened. Exiting!" << endl;
exit (1);
}
// open the BAM file
BamReader reader;
reader.Open(_bamFile);
BamAlignment bam;
while (reader.GetNextAlignment(bam)) {
// extract the sequence and qualities for the BAM "query"
string seq = bam.QueryBases;
string qual = bam.Qualities;
if (bam.IsReverseStrand() == true) {
reverseComplement(seq);
reverseSequence(qual);
}
fq << "@" << bam.Name << endl;
fq << seq << endl;
fq << "+" << endl;
fq << qual << endl;
}
}
bool RevertTool::RevertToolPrivate::Run(void) {
// opens the BAM file without checking for indexes
BamReader reader;
if ( !reader.Open(m_settings->InputFilename) ) {
cerr << "Could not open input BAM file... quitting." << endl;
return false;
}
// get BAM file metadata
const string& headerText = reader.GetHeaderText();
const RefVector& references = reader.GetReferenceData();
// open writer
BamWriter writer;
bool writeUncompressed = ( m_settings->OutputFilename == Options::StandardOut() && !m_settings->IsForceCompression );
if ( !writer.Open(m_settings->OutputFilename, headerText, references, writeUncompressed) ) {
cerr << "Could not open " << m_settings->OutputFilename << " for writing." << endl;
return false;
}
// plow through file, reverting alignments
BamAlignment al;
while ( reader.GetNextAlignment(al) ) {
RevertAlignment(al);
writer.SaveAlignment(al);
}
// clean and exit
reader.Close();
writer.Close();
return true;
}
void BedIntersectPE::IntersectBamPE(string bamFile) {
// load the "B" bed file into a map so
// that we can easily compare "A" to it for overlaps
_bedB->loadBedFileIntoMap();
// open the BAM file
BamReader reader;
BamWriter writer;
reader.Open(bamFile);
// get header & reference information
string bamHeader = reader.GetHeaderText();
RefVector refs = reader.GetReferenceData();
// open a BAM output to stdout if we are writing BAM
if (_bamOutput == true) {
// set compression mode
BamWriter::CompressionMode compressionMode = BamWriter::Compressed;
if ( _isUncompressedBam ) compressionMode = BamWriter::Uncompressed;
writer.SetCompressionMode(compressionMode);
// open our BAM writer
writer.Open("stdout", bamHeader, refs);
}
// track the previous and current sequence
// names so that we can identify blocks of
// alignments for a given read ID.
string prevName, currName;
prevName = currName = "";
vector<BamAlignment> alignments; // vector of BAM alignments for a given ID in a BAM file.
alignments.reserve(100);
_bedA->bedType = 10; // it's a full BEDPE given it's BAM
// rip through the BAM file and convert each mapped entry to BEDPE
BamAlignment bam1, bam2;
while (reader.GetNextAlignment(bam1)) {
// the alignment must be paired
if (bam1.IsPaired() == true) {
// grab the second alignment for the pair.
reader.GetNextAlignment(bam2);
// require that the alignments are from the same query
if (bam1.Name == bam2.Name) {
ProcessBamBlock(bam1, bam2, refs, writer);
}
else {
cerr << "*****ERROR: -bedpe requires BAM to be sorted or grouped by query name. " << endl;
exit(1);
}
}
}
// close up
reader.Close();
if (_bamOutput == true) {
writer.Close();
}
}
int main (int argc, char *argv[]) {
string bamfiletopen = string(argv[1]);
BamReader reader;
if ( !reader.Open(bamfiletopen) ) {
cerr << "Could not open input BAM files." << endl;
return 1;
}
BamAlignment al;
while ( reader.GetNextAlignment(al) ) {
string reconstructedReference = reconstructRef(&al);
cout<<al.QueryBases<<endl;
cout<<reconstructedReference<<endl;
pair< string, vector<int> > reconP = reconstructRefWithPos(&al);
for(unsigned int i=0;i<reconP.first.size();i++){
cout<<reconP.first[i]<<"\t"<<reconP.second[i]<<endl;
}
}
reader.Close();
return 0;
}
/*
Description:
Load all the bam into memory at one time if no parameters set, otherwise load the needed part of the bam.
Save the parsed info into vector.
*/
bool BamParse::parseAlignment(int chrom1, int chrom1_begin, int chrom2, int chrom2_end)
{
BamReader reader;
if ( !reader.Open(filename) ) {
cerr << "Bamtools ERROR: could not open input BAM file: " << filename << endl;
return false;
}
//check whether need to set a region.
if(chrom1>-1 && chrom1_begin>-1 && chrom2>-1 && chrom2_end>-1)
{
this->loadIndex(reader);
BamRegion br(chrom1,chrom1_begin,chrom2,chrom2_end);
bool is_set=reader.SetRegion(br);
if(is_set==false)
{
return false;//cannot set the region.
}
}
//process input data
BamAlignment al;
while ( reader.GetNextAlignment(al) )
{
if(al.Position<0) continue;
BamAlignmentRecord* bar=new BamAlignmentRecord();
setAlignmentRecord(al,bar);
bam_aln_records.push_back(bar);
}
reader.Close();
return true;
}
// opens BAM files
bool BamMultiReaderPrivate::Open(const vector<string>& filenames) {
m_errorString.clear();
// put all current readers back at beginning (refreshes alignment cache)
if ( !Rewind() ) {
const string currentError = m_errorString;
const string message = string("unable to rewind existing readers: \n\t") + currentError;
SetErrorString("BamMultiReader::Open", message);
return false;
}
// iterate over filenames
bool errorsEncountered = false;
vector<string>::const_iterator filenameIter = filenames.begin();
vector<string>::const_iterator filenameEnd = filenames.end();
for ( ; filenameIter != filenameEnd; ++filenameIter ) {
const string& filename = (*filenameIter);
if ( filename.empty() ) continue;
// attempt to open BamReader
BamReader* reader = new BamReader;
const bool readerOpened = reader->Open(filename);
// if opened OK, store it
if ( readerOpened )
m_readers.push_back( MergeItem(reader, new BamAlignment) );
// otherwise store error & clean up invalid reader
else {
m_errorString.append(1, '\t');
m_errorString += string("unable to open file: ") + filename;
m_errorString.append(1, '\n');
errorsEncountered = true;
delete reader;
reader = 0;
}
}
// check for errors while opening
if ( errorsEncountered ) {
const string currentError = m_errorString;
const string message = string("unable to open all files: \t\n") + currentError;
SetErrorString("BamMultiReader::Open", message);
return false;
}
// check for BAM file consistency
if ( !ValidateReaders() ) {
const string currentError = m_errorString;
const string message = string("unable to open inconsistent files: \t\n") + currentError;
SetErrorString("BamMultiReader::Open", message);
return false;
}
// update alignment cache
return UpdateAlignmentCache();
}
/**
* Main work method. Reads the BAM file once and collects sorted information about
* the 5' ends of both ends of each read (or just one end in the case of pairs).
* Then makes a pass through those determining duplicates before re-reading the
* input file and writing it out with duplication flags set correctly.
*/
int MarkDuplicates::runInternal() {
ogeNameThread("am_MarkDuplicates");
if(verbose)
cerr << "Reading input file and constructing read end information." << endl;
buildSortedReadEndLists();
generateDuplicateIndexes();
if(verbose)
cerr << "Marking " << numDuplicateIndices << " records as duplicates." << endl;
BamReader in;
in.Open(getBufferFileName());
// Now copy over the file while marking all the necessary indexes as duplicates
long recordInFileIndex = 0;
long written = 0;
while (true) {
BamAlignment * prec = in.GetNextAlignment();
if(!prec)
break;
if (prec->IsPrimaryAlignment()) {
if (duplicateIndexes.count(recordInFileIndex) == 1)
prec->SetIsDuplicate(true);
else
prec->SetIsDuplicate(false);
}
recordInFileIndex++;
if (removeDuplicates && prec->IsDuplicate()) {
// do nothing
}
else {
putOutputAlignment(prec);
if (verbose && read_count && ++written % 100000 == 0) {
cerr << "\rWritten " << written << " records (" << written * 100 / read_count <<"%)." << std::flush;
}
}
}
if (verbose && read_count)
cerr << "\rWritten " << written << " records (" << written * 100 / read_count <<"%)." << endl;
in.Close();
remove(getBufferFileName().c_str());
return 0;
}
void BedCoverage::CollectCoverageBam(string bamFile) {
// load the "B" bed file into a map so
// that we can easily compare "A" to it for overlaps
_bedB->loadBedCovFileIntoMap();
// open the BAM file
BamReader reader;
reader.Open(bamFile);
// get header & reference information
string header = reader.GetHeaderText();
RefVector refs = reader.GetReferenceData();
// convert each aligned BAM entry to BED
// and compute coverage on B
BamAlignment bam;
while (reader.GetNextAlignment(bam)) {
if (bam.IsMapped()) {
// treat the BAM alignment as a single "block"
if (_obeySplits == false) {
// construct a new BED entry from the current BAM alignment.
BED a;
a.chrom = refs.at(bam.RefID).RefName;
a.start = bam.Position;
a.end = bam.GetEndPosition(false, false);
a.strand = "+";
if (bam.IsReverseStrand()) a.strand = "-";
_bedB->countHits(a, _sameStrand, _diffStrand, _countsOnly);
}
// split the BAM alignment into discrete blocks and
// look for overlaps only within each block.
else {
// vec to store the discrete BED "blocks" from a
bedVector bedBlocks;
// since we are counting coverage, we do want to split blocks when a
// deletion (D) CIGAR op is encountered (hence the true for the last parm)
GetBamBlocks(bam, refs.at(bam.RefID).RefName, bedBlocks, false, true);
// use countSplitHits to avoid over-counting each split chunk
// as distinct read coverage.
_bedB->countSplitHits(bedBlocks, _sameStrand, _diffStrand, _countsOnly);
}
}
}
// report the coverage (summary or histogram) for BED B.
if (_countsOnly == true)
ReportCounts();
else
ReportCoverage();
// close the BAM file
reader.Close();
}
void parser::fetchLines(vector<BamAlignment>& result, uint32_t n,
const std::string& file) {
BamReader bam;
BamAlignment read;
Guarded<FileNotGood> g(!(bam.Open(file)), file.c_str());
const RefVector refvec = bam.GetReferenceData();
while (bam.GetNextAlignment(read) && n) {
result.push_back(read);
// cout << "read " << n << "\t" << read << "\n";
n--;
}
}
bool CoverageTool::CoverageToolPrivate::Run(void) {
// if output filename given
ofstream outFile;
if ( m_settings->HasOutputFile ) {
// open output file stream
outFile.open(m_settings->OutputFilename.c_str());
if ( !outFile ) {
cerr << "bamtools coverage ERROR: could not open " << m_settings->OutputFilename
<< " for output" << endl;
return false;
}
// set m_out to file's streambuf
m_out.rdbuf(outFile.rdbuf());
}
//open our BAM reader
BamReader reader;
if ( !reader.Open(m_settings->InputBamFilename) ) {
cerr << "bamtools coverage ERROR: could not open input BAM file: " << m_settings->InputBamFilename << endl;
return false;
}
// retrieve references
m_references = reader.GetReferenceData();
// set up our output 'visitor'
CoverageVisitor* cv = new CoverageVisitor(m_references, &m_out);
// set up pileup engine with 'visitor'
PileupEngine pileup;
pileup.AddVisitor(cv);
// process input data
BamAlignment al;
while ( reader.GetNextAlignment(al) )
pileup.AddAlignment(al);
// clean up
reader.Close();
if ( m_settings->HasOutputFile )
outFile.close();
delete cv;
cv = 0;
// return success
return true;
}
int main (int argc, char *argv[]) {
if( (argc== 1) ||
(argc== 2 && string(argv[1]) == "-h") ||
(argc== 2 && string(argv[1]) == "-help") ||
(argc== 2 && string(argv[1]) == "--help") ){
cout<<"Usage:setAsUnpaired [in bam] [outbam]"<<endl<<"this program takes flags all paired sequences as singles"<<endl;
return 1;
}
string bamfiletopen = string(argv[1]);
string bamFileOUT = string(argv[2]);
BamReader reader;
BamWriter writer;
if ( !reader.Open(bamfiletopen) ) {
cerr << "Could not open input BAM files." << endl;
return 1;
}
const SamHeader header = reader.GetHeader();
const RefVector references = reader.GetReferenceData();
if ( !writer.Open(bamFileOUT,header,references) ) {
cerr << "Could not open output BAM file "<<bamFileOUT << endl;
return 1;
}
BamAlignment al;
while ( reader.GetNextAlignment(al) ) {
if(al.IsMapped()){
cerr << "Cannot yet handle mapped reads " << endl;
return 1;
}
al.SetIsPaired (false);
writer.SaveAlignment(al);
} //while al
reader.Close();
writer.Close();
return 0;
}
int main (int argc, char *argv[]) {
if( (argc== 1) ||
(argc== 2 && string(argv[1]) == "-h") ||
(argc== 2 && string(argv[1]) == "-help") ||
(argc== 2 && string(argv[1]) == "--help") ){
cout<<"Usage:editDist [in bam]"<<endl<<"this program returns the NM field of all aligned reads"<<endl;
return 1;
}
string bamfiletopen = string(argv[1]);
// cout<<bamfiletopen<<endl;
BamReader reader;
// cout<<"ok"<<endl;
if ( !reader.Open(bamfiletopen) ) {
cerr << "Could not open input BAM files." << endl;
return 1;
}
BamAlignment al;
// cout<<"ok"<<endl;
while ( reader.GetNextAlignment(al) ) {
// cout<<al.Name<<endl;
if(!al.IsMapped())
continue;
if(al.HasTag("NM") ){
int editDist;
if(al.GetTag("NM",editDist) ){
cout<<editDist<<endl;
}else{
cerr<<"Cannot retrieve NM field for "<<al.Name<<endl;
return 1;
}
}else{
cerr<<"Warning: read "<<al.Name<<" is aligned but has no NM field"<<endl;
}
} //while al
reader.Close();
return 0;
}
int IndexTool::Run(int argc, char* argv[]) {
// parse command line arguments
Options::Parse(argc, argv, 1);
// open our BAM reader
BamReader reader;
reader.Open(m_settings->InputBamFilename);
// create index for BAM file
bool useDefaultIndex = !m_settings->IsUsingBamtoolsIndex;
reader.CreateIndex(useDefaultIndex);
// clean & exit
reader.Close();
return 0;
}
// opens BAM files
bool BamMultiReader::Open(const vector<string>& filenames, bool openIndexes, bool coreMode, bool preferStandardIndex) {
// for filename in filenames
fileNames = filenames; // save filenames in our multireader
for (vector<string>::const_iterator it = filenames.begin(); it != filenames.end(); ++it) {
const string filename = *it;
BamReader* reader = new BamReader;
bool openedOK = true;
openedOK = reader->Open(filename, "", openIndexes, preferStandardIndex);
// if file opened ok, check that it can be read
if ( openedOK ) {
bool fileOK = true;
BamAlignment* alignment = new BamAlignment;
fileOK &= ( coreMode ? reader->GetNextAlignmentCore(*alignment) : reader->GetNextAlignment(*alignment) );
if (fileOK) {
readers.push_back(make_pair(reader, alignment)); // store pointers to our readers for cleanup
alignments.insert(make_pair(make_pair(alignment->RefID, alignment->Position),
make_pair(reader, alignment)));
} else {
cerr << "WARNING: could not read first alignment in " << filename << ", ignoring file" << endl;
// if only file available & could not be read, return failure
if ( filenames.size() == 1 ) return false;
}
}
// TODO; any further error handling when openedOK is false ??
else
return false;
}
// files opened ok, at least one alignment could be read,
// now need to check that all files use same reference data
ValidateReaders();
return true;
}
void StructuralVariations::findTranslocationsOnTheFly(string bamFileName, bool outtie, float meanCoverage, string outputFileHeader, map<string,int> SV_options) {
size_t start = time(NULL);
//open the bam file
BamReader bamFile;
bamFile.Open(bamFileName);
//Information from the header is needed to initialize the data structure
SamHeader head = bamFile.GetHeader();
// now create Translocation on the fly
Window *window;
window = new Window(bamFileName,outtie,meanCoverage,outputFileHeader,SV_options);
window->initTrans(head);
//expands a vector so that it is large enough to hold reads from each contig in separate elements
window->eventReads.resize(SV_options["contigsNumber"]);
window->eventSplitReads.resize(SV_options["contigsNumber"]);
window-> binnedCoverage.resize(SV_options["contigsNumber"]);
window-> linksFromWin.resize(SV_options["contigsNumber"]);
window -> numberOfEvents = 0;
string line;
string coverageFile=outputFileHeader+".tab";
ifstream inputFile( coverageFile.c_str() );
int line_number=0;
while (std::getline( inputFile, line )){
if(line_number > 0){
vector<string> splitline;
std::stringstream ss(line);
std::string item;
while (std::getline(ss, item, '\t')) {
splitline.push_back(item);
}
window -> binnedCoverage[window -> contig2position[splitline[0]]].push_back(atof(splitline[3].c_str()));
}
line_number += 1;
}
inputFile.close();
//Initialize bam entity
BamAlignment currentRead;
//now start to iterate over the bam file
int counter = 0;
while ( bamFile.GetNextAlignmentCore(currentRead) ) {
if(currentRead.IsMapped()) {
window->insertRead(currentRead);
}
}
for(int i=0;i< window-> eventReads.size();i++){
if(window -> eventReads[i].size() >= window -> minimumPairs){
window->computeVariations(i);
}
window->eventReads[i]=queue<BamAlignment>();
window->eventSplitReads[i] = vector<BamAlignment>();
}
window->interChrVariationsVCF.close();
window->intraChrVariationsVCF.close();
printf ("variant calling time consumption= %lds\n", time(NULL) - start);
}
void BamToFastq::PairedFastq() {
// open the 1st fastq file for writing
ofstream fq1(_fastq1.c_str(), ios::out);
if ( !fq1 ) {
cerr << "Error: The first fastq file (" << _fastq1 << ") could not be opened. Exiting!" << endl;
exit (1);
}
// open the 2nd fastq file for writing
ofstream fq2(_fastq2.c_str(), ios::out);
if ( !fq2 ) {
cerr << "Error: The second fastq file (" << _fastq2 << ") could not be opened. Exiting!" << endl;
exit (1);
}
// open the BAM file
BamReader reader;
reader.Open(_bamFile);
// rip through the BAM file and convert each mapped entry to BEDPE
BamAlignment bam1, bam2;
bool shouldConsumeReads = true;
while (true) {
if (shouldConsumeReads) {
if (!reader.GetNextAlignment(bam1) || !reader.GetNextAlignment(bam2)) break;
} else {
shouldConsumeReads = true;
}
if (bam1.Name != bam2.Name) {
while (bam1.Name != bam2.Name)
{
if (bam1.IsPaired())
{
cerr << "*****WARNING: Query " << bam1.Name
<< " is marked as paired, but its mate does not occur"
<< " next to it in your BAM file. Skipping. " << endl;
}
bam1 = bam2;
if (!reader.GetNextAlignment(bam2)) break;
shouldConsumeReads = false;
}
}
else if (bam1.IsPaired() && bam2.IsPaired()) {
// extract the sequence and qualities for the BAM "query"
string seq1 = bam1.QueryBases;
string qual1 = bam1.Qualities;
string seq2 = bam2.QueryBases;
string qual2 = bam2.Qualities;
if (bam1.IsReverseStrand() == true) {
reverseComplement(seq1);
reverseSequence(qual1);
}
if (bam2.IsReverseStrand() == true) {
reverseComplement(seq2);
reverseSequence(qual2);
}
fq1 << "@" << bam1.Name << "/1" << endl;
fq1 << seq1 << endl;
fq1 << "+" << endl;
fq1 << qual1 << endl;
fq2 << "@" << bam2.Name << "/2" << endl;
fq2 << seq2 << endl;
fq2 << "+" << endl;
fq2 << qual2 << endl;
}
}
reader.Close();
}
//{{{ bool merge_sorted_files(string out_file_name,
bool merge_sorted_files(string out_file_name,
int buff_count,
string header_text,
RefVector &ref)
{
map<string,BamReader*> bam_readers;
priority_queue< BamAlignment, vector<BamAlignment>, inter_chrom_rev_sort > q;
for (int i = 0; i < buff_count; ++i) {
stringstream temp_name;
temp_name << out_file_name << i;
BamReader *reader = new BamReader();
if ( !reader->Open(temp_name.str()) ) {
cerr << "sort ERROR: could not open " <<
temp_name.str() << " for reading... Aborting." << endl;
return false;
}
bam_readers[temp_name.str()] = reader;
// place an item from each bam onto the q
BamAlignment al;
if (reader->GetNextAlignment(al))
q.push(al);
}
BamWriter merged_writer;
if ( !merged_writer.Open(out_file_name, header_text, ref) ) {
cerr << "sort ERROR: could not open " << out_file_name
<< " for writing." << endl;
return false;
}
while (!q.empty()) {
BamAlignment al = q.top();
q.pop();
merged_writer.SaveAlignment(al);
BamReader *reader = bam_readers[al.Filename];
BamAlignment new_al;
if (reader->GetNextAlignment(new_al))
q.push(new_al);
}
merged_writer.Close();
//close and remove temp files
map<string,BamReader*>::iterator it;
for (it = bam_readers.begin(); it != bam_readers.end(); ++it) {
BamReader *reader = it->second;
reader->Close();
delete reader;
remove(it->first.c_str());
}
return true;
}
int main (int argc, char *argv[]) {
int minBaseQuality = 0;
string usage=string(""+string(argv[0])+" [in BAM file] [in VCF file] [chr name] [deam out BAM] [not deam out BAM]"+
"\nThis program divides aligned single end reads into potentially deaminated\n"+
"\nreads and the puts the rest into another bam file if the deaminated positions are not called as the alternative base in the VCF.\n"+
"\nTip: if you do not need one of them, use /dev/null as your output\n"+
"arguments:\n"+
"\t"+"--bq [base qual] : Minimum base quality to flag a deaminated site (Default: "+stringify(minBaseQuality)+")\n"+
"\n");
if(argc == 1 ||
argc < 4 ||
(argc == 2 && (string(argv[0]) == "-h" || string(argv[0]) == "--help") )
){
cerr << "Usage "<<usage<<endl;
return 1;
}
for(int i=1;i<(argc-2);i++){
if(string(argv[i]) == "--bq"){
minBaseQuality=destringify<int>(argv[i+1]);
i++;
continue;
}
}
string bamfiletopen = string( argv[ argc-5 ] );
string vcffiletopen = string( argv[ argc-4 ] );
string chrname = string( argv[ argc-3 ] );
string deambam = string( argv[ argc-2 ] );
string nondeambam = string( argv[ argc-1 ] );
//dummy reader, will need to reposition anyway
VCFreader vcfr (vcffiletopen,
vcffiletopen+".tbi",
chrname,
1,
1,
0);
BamReader reader;
if ( !reader.Open(bamfiletopen) ) {
cerr << "Could not open input BAM file"<< bamfiletopen << endl;
return 1;
}
// if ( !reader.LocateIndex() ) {
// cerr << "The index for the BAM file cannot be located" << endl;
// return 1;
// }
// if ( !reader.HasIndex() ) {
// cerr << "The BAM file has not been indexed." << endl;
// return 1;
// }
//positioning the bam file
int refid=reader.GetReferenceID(chrname);
if(refid < 0){
cerr << "Cannot retrieve the reference ID for "<< chrname << endl;
return 1;
}
//cout<<"redif "<<refid<<endl;
//setting the BAM reader at that position
reader.SetRegion(refid,
0,
refid,
-1);
vector<RefData> testRefData=reader.GetReferenceData();
const SamHeader header = reader.GetHeader();
const RefVector references = reader.GetReferenceData();
BamWriter writerDeam;
if ( !writerDeam.Open(deambam, header, references) ) {
cerr << "Could not open output BAM file" << endl;
return 1;
}
BamWriter writerNoDeam;
if ( !writerNoDeam.Open(nondeambam, header, references) ) {
cerr << "Could not open output BAM file" << endl;
return 1;
}
unsigned int totalReads =0;
unsigned int deaminatedReads =0;
unsigned int ndeaminatedReads =0;
unsigned int skipped =0;
//iterating over the alignments for these regions
BamAlignment al;
int i;
while ( reader.GetNextAlignment(al) ) {
// cerr<<al.Name<<endl;
//skip unmapped
if(!al.IsMapped()){
skipped++;
continue;
}
//skip paired end !
if(al.IsPaired() ){
continue;
// cerr<<"Paired end not yet coded"<<endl;
// return 1;
}
string reconstructedReference = reconstructRef(&al);
char refeBase;
char readBase;
bool isDeaminated;
if(al.Qualities.size() != reconstructedReference.size()){
cerr<<"Quality line is not the same size as the reconstructed reference"<<endl;
return 1;
}
isDeaminated=false;
if(al.IsReverseStrand()){
//first base next to 3'
i = 0 ;
refeBase=toupper(reconstructedReference[i]);
readBase=toupper( al.QueryBases[i]);
if( readBase == 'A' && int(al.Qualities[i]-offset) >= minBaseQuality){ //isDeaminated=true; }
if( skipAlign(reconstructedReference,&al,&skipped) ){ continue; }
transformRef(&refeBase,&readBase);
vcfr.repositionIterator(chrname,al.Position+1,al.Position+1);
while(vcfr.hasData()){
SimpleVCF * toprint=vcfr.getData();
// cout<<*toprint<<endl;
//skip deletions in the alt
if(toprint->getRef().length() != 1 )
continue;
if(toprint->getRef()[0] != refeBase){
cerr<<reconstructedReference<<endl;
cerr<<al.Position<<endl;
cerr<<numberOfDeletions(&al)<<endl;
cerr<<"Problem1 position "<<*toprint<<" does not have a "<<refeBase<<" as reference allele for read "<<al.Name<<endl;
exit(1);
}
//if the VCF has a at least one G but no A
if( toprint->hasAtLeastOneG() &&
!toprint->hasAtLeastOneA() ){
isDeaminated=true;
}
}
}
//second base next to 3'
i = 1;
refeBase=toupper(reconstructedReference[i]);
readBase=toupper( al.QueryBases[i]);
//refeBase == 'G' &&
if( readBase == 'A' && int(al.Qualities[i]-offset) >= minBaseQuality){ //isDeaminated=true; }
if( skipAlign(reconstructedReference,&al,&skipped) ){ continue; }
transformRef(&refeBase,&readBase);
vcfr.repositionIterator(chrname,al.Position+2,al.Position+2);
while(vcfr.hasData()){
SimpleVCF * toprint=vcfr.getData();
// cout<<*toprint<<endl;
//skip deletions in the alt
if(toprint->getRef().length() != 1 )
continue;
if(toprint->getRef()[0] != refeBase){
cerr<<reconstructedReference<<endl;
cerr<<al.Position<<endl;
cerr<<numberOfDeletions(&al)<<endl;
cerr<<"Problem2 position "<<*toprint<<" does not have a "<<refeBase<<" as reference allele for read "<<al.Name<<endl;
exit(1);
}
//if the VCF has at least one G but no A
// if(toprint->hasAtLeastOneG() &&
// toprint->getAlt().find("A") == string::npos){
if( toprint->hasAtLeastOneG() &&
!toprint->hasAtLeastOneA() ){
isDeaminated=true;
}
}
}
//last base next to 5'
i = (al.QueryBases.length()-1) ;
refeBase=toupper(reconstructedReference[i]);
readBase=toupper( al.QueryBases[i]);
//refeBase == 'G' &&
if( readBase == 'A' && int(al.Qualities[i]-offset) >= minBaseQuality){ //isDeaminated=true; }
if( skipAlign(reconstructedReference,&al,&skipped) ){ continue; }
transformRef(&refeBase,&readBase);
int lengthMatches=countMatchesRecons(reconstructedReference,0);
int positionJump = al.Position+lengthMatches+numberOfDeletions(&al);
vcfr.repositionIterator(chrname,positionJump,positionJump);
while(vcfr.hasData()){
SimpleVCF * toprint=vcfr.getData();
//skip deletions in the alt
if(toprint->getRef().length() != 1 )
continue;
if(toprint->getRef()[0] != refeBase){
cerr<<reconstructedReference<<endl;
cerr<<al.Position<<endl;
cerr<<lengthMatches<<endl;
cerr<<numberOfDeletions(&al)<<endl;
cerr<<positionJump<<endl;
cerr<<"Problem3 position "<<*toprint<<" does not have a "<<refeBase<<" as reference allele for read "<<al.Name<<endl;
exit(1);
}
//if the VCF has at least one G but no A
if( toprint->hasAtLeastOneG() &&
!toprint->hasAtLeastOneA() ){
isDeaminated=true;
}
}
}
}else{
//first base next to 5'
i = 0;
refeBase=toupper(reconstructedReference[i]);
readBase=toupper( al.QueryBases[i]);
//refeBase == 'C'
if( readBase == 'T' && int(al.Qualities[i]-offset) >= minBaseQuality){
if( skipAlign(reconstructedReference,&al,&skipped) ){ continue; }
transformRef(&refeBase,&readBase);
vcfr.repositionIterator(chrname,al.Position+1,al.Position+1);
while(vcfr.hasData()){
SimpleVCF * toprint=vcfr.getData();
//cout<<*toprint<<endl;
//skip deletions in the alt
if(toprint->getRef().length() != 1 )
continue;
if(toprint->getRef()[0] != refeBase){
cerr<<reconstructedReference<<endl;
cerr<<al.Position<<endl;
cerr<<numberOfDeletions(&al)<<endl;
cerr<<"Problem4 position "<<*toprint<<" does not have a "<<refeBase<<" as reference allele for read "<<al.Name<<endl;
exit(1);
}
//if the VCF has at least one C but no T
if( toprint->hasAtLeastOneC() &&
!toprint->hasAtLeastOneT() ){
isDeaminated=true;
}
}
//cout<<al.Position+
}
//second last base next to 3'
i = (al.QueryBases.length()-2);
refeBase=toupper(reconstructedReference[i]);
readBase=toupper( al.QueryBases[i]);
//refeBase == 'C' &&
if( readBase == 'T' && int(al.Qualities[i]-offset) >= minBaseQuality){
if( skipAlign(reconstructedReference,&al,&skipped) ){ continue; }
transformRef(&refeBase,&readBase);
int lengthMatches=countMatchesRecons(reconstructedReference,1);
int positionJump = al.Position+lengthMatches+numberOfDeletions(&al);
vcfr.repositionIterator(chrname,positionJump,positionJump);
while(vcfr.hasData()){
SimpleVCF * toprint=vcfr.getData();
//skip deletions in the alt
if(toprint->getRef().length() != 1 )
continue;
if(toprint->getRef()[0] != refeBase){
cerr<<reconstructedReference<<endl;
cerr<<al.Position<<endl;
cerr<<lengthMatches<<endl;
cerr<<numberOfDeletions(&al)<<endl;
cerr<<positionJump<<endl;
cerr<<"Problem5 position "<<*toprint<<" does not have a "<<refeBase<<" as reference allele for read "<<al.Name<<endl;
exit(1);
}
if( toprint->hasAtLeastOneC() &&
!toprint->hasAtLeastOneT() ){
isDeaminated=true;
}
}
}
//last base next to 3'
i = (al.QueryBases.length()-1);
refeBase=toupper(reconstructedReference[i]);
readBase=toupper( al.QueryBases[i]);
//&& refeBase == 'C'
if( readBase == 'T' && int(al.Qualities[i]-offset) >= minBaseQuality){
if( skipAlign(reconstructedReference,&al,&skipped) ){ continue; }
transformRef(&refeBase,&readBase);
int lengthMatches=countMatchesRecons(reconstructedReference,0);
int positionJump = al.Position+lengthMatches+numberOfDeletions(&al);
vcfr.repositionIterator(chrname,positionJump,positionJump);
while(vcfr.hasData()){
SimpleVCF * toprint=vcfr.getData();
//skip deletions in the alt
if(toprint->getRef().length() != 1 )
continue;
if(toprint->getRef()[0] != refeBase){
cerr<<reconstructedReference<<endl;
cerr<<al.Position<<endl;
cerr<<lengthMatches<<endl;
cerr<<numberOfDeletions(&al)<<endl;
cerr<<positionJump<<endl;
cerr<<"Problem6 position "<<*toprint<<" does not have a "<<refeBase<<" as reference allele for read "<<al.Name<<endl;
exit(1);
}
if( toprint->hasAtLeastOneC() &&
!toprint->hasAtLeastOneT() ){
isDeaminated=true;
}
}
}
}
totalReads++;
if(isDeaminated){
deaminatedReads++;
writerDeam.SaveAlignment(al);
}else{
ndeaminatedReads++;
writerNoDeam.SaveAlignment(al);
}
}//end for each read
reader.Close();
writerDeam.Close();
writerNoDeam.Close();
cerr<<"Program finished sucessfully, out of "<<totalReads<<" mapped reads (skipped: "<<skipped<<" reads) we flagged "<<deaminatedReads<<" as deaminated and "<<ndeaminatedReads<<" as not deaminated"<<endl;
return 0;
}
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;
}
//{{{bool sort_inter_chrom_bam(string in_file_name,
bool sort_inter_chrom_bam(string in_file_name,
string out_file_name)
{
// open input BAM file
BamReader reader;
if ( !reader.Open(in_file_name) ) {
cerr << "sort ERROR: could not open " <<
in_file_name << " for reading... Aborting." << endl;
return false;
}
SamHeader header = reader.GetHeader();
if ( !header.HasVersion() )
header.Version = Constants::SAM_CURRENT_VERSION;
string header_text = header.ToString();
RefVector ref = reader.GetReferenceData();
// set up alignments buffer
BamAlignment al;
vector<BamAlignment> buffer;
buffer.reserve( (size_t)(SORT_DEFAULT_MAX_BUFFER_COUNT*1.1) );
bool bufferFull = false;
int buff_count = 0;
// iterate through file
while ( reader.GetNextAlignment(al)) {
// check buffer's usage
bufferFull = ( buffer.size() >= SORT_DEFAULT_MAX_BUFFER_COUNT );
// store alignments until buffer is "full"
if ( !bufferFull )
buffer.push_back(al);
// if buffer is "full"
else {
// so create a sorted temp file with current buffer contents
// then push "al" into fresh buffer
create_sorted_temp_file(buffer,
out_file_name,
buff_count,
header_text,
ref);
++buff_count;
buffer.push_back(al);
}
}
// handle any leftover buffer contents
if ( !buffer.empty() ) {
create_sorted_temp_file(buffer,
out_file_name,
buff_count,
header_text,
ref);
++buff_count;
}
reader.Close();
return merge_sorted_files(out_file_name, buff_count, header_text, ref);
/*
for (int i = 0; i < buff_count; ++i) {
stringstream temp_name;
temp_name << out_file_name << i;
}
*/
}
void BedIntersectPE::IntersectBamPE(string bamFile) {
// load the "B" bed file into a map so
// that we can easily compare "A" to it for overlaps
_bedB->loadBedFileIntoMap();
// open the BAM file
BamReader reader;
BamWriter writer;
reader.Open(bamFile);
// get header & reference information
string bamHeader = reader.GetHeaderText();
RefVector refs = reader.GetReferenceData();
// open a BAM output to stdout if we are writing BAM
if (_bamOutput == true) {
// set compression mode
BamWriter::CompressionMode compressionMode = BamWriter::Compressed;
if ( _isUncompressedBam ) compressionMode = BamWriter::Uncompressed;
writer.SetCompressionMode(compressionMode);
// open our BAM writer
writer.Open("stdout", bamHeader, refs);
}
// track the previous and current sequence
// names so that we can identify blocks of
// alignments for a given read ID.
string prevName, currName;
prevName = currName = "";
vector<BamAlignment> alignments; // vector of BAM alignments for a given ID in a BAM file.
alignments.reserve(100);
_bedA->bedType = 10; // it's a full BEDPE given it's BAM
// rip through the BAM file and convert each mapped entry to BEDPE
BamAlignment bam1, bam2;
while (reader.GetNextAlignment(bam1)) {
reader.GetNextAlignment(bam2);
if (bam1.Name != bam2.Name) {
while (bam1.Name != bam2.Name)
{
if (bam1.IsPaired())
{
cerr << "*****WARNING: Query " << bam1.Name
<< " is marked as paired, but it's mate does not occur"
<< " next to it in your BAM file. Skipping. " << endl;
}
bam1 = bam2;
reader.GetNextAlignment(bam2);
}
}
else if (bam1.IsPaired() && bam1.IsPaired()) {
ProcessBamBlock(bam1, bam2, refs, writer);
}
}
// close up
reader.Close();
if (_bamOutput == true) {
writer.Close();
}
}
int CropBamTool::parseCommandLine(int argc, char *argv[])
{
auto isHexString = [](string s)
{
for (auto c : s)
{
if (c=='x') return true;
if (c=='X') return true;
}
return false;
};
int c;
while (1)
{
static struct option long_options[] =
{
{"roi", required_argument, 0, 0},
{"roi-list", required_argument, 0, 0},
{"mq", required_argument, 0, 0},
{"len", required_argument, 0, 0},
{"slen", required_argument, 0, 0},
{"iden", required_argument, 0, 0},
{"ff", required_argument, 0, 0},
{"num-cores", required_argument, 0, 0},
{"format", required_argument, 0, 0},
{"keep-clip", required_argument, 0, 0},
{"uniq", no_argument, 0, 0},
{"freq", required_argument, 0, 0},
{"freq-thres", required_argument, 0, 0},
{"verbose", required_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{0,0,0,0}
};
// getopt_long stores the option index here
int option_index = 0;
c = getopt_long(argc, argv, "v:h", long_options, &option_index);
// detect the end of the options
if (c==-1) break;
switch(c)
{
case 0:
switch(option_index)
{
case 0:
regionStrings.emplace_back(optarg);
break;
case 1:
{
ifstream infile(optarg);
string line;
while (getline(infile,line))
{
if (!line.empty())
regionStrings.emplace_back(optarg);
}
infile.close();
}
break;
case 2:
mapQualThres=stoi(optarg);
break;
case 3:
readLenThres=stoi(optarg);
break;
case 4:
segmentLenThres=stoi(optarg);
break;
case 5:
alnIdenThres=stod(optarg);
break;
case 6:
if (isHexString(optarg)){
alnFlagMarker |= stoul(optarg,nullptr,16);
}else{
alnFlagMarker |= stoi(optarg);
}
break;
case 7:
numThreads=stoi(optarg);
break;
case 8:
outFormat=optarg;
break;
case 9:
keepClip=true;
break;
case 10:
useUnique = true;
break;
case 11:
outFreq = optarg;
break;
case 12:
thresFreq = stoi(optarg);
break;
default:
abort();
}
break;
case 'v':
verbose=stoi(optarg);
break;
case 'h':
Help();
exit(EXIT_SUCCESS);
break;
case '?':
exit(EXIT_FAILURE);
break;
default:
abort();
}
}
// bam file
for (; optind<argc;)
{
bamFiles.emplace_back(argv[optind++]);
// check the existence of the bam file
auto f=*bamFiles.rbegin();
BamReader bamReader;
if (!bamReader.Open(f))
{
cerr << "[PyroTools-CropBam] error: "
<< f << " not existed or invalid" << endl;
exit(EXIT_FAILURE);
}
}
return 0;
}
// generates mutiple sorted temp BAM files from single unsorted BAM file
bool SortTool::SortToolPrivate::GenerateSortedRuns(void) {
// open input BAM file
BamReader reader;
if ( !reader.Open(m_settings->InputBamFilename) ) {
cerr << "bamtools sort ERROR: could not open " << m_settings->InputBamFilename
<< " for reading... Aborting." << endl;
return false;
}
// get basic data that will be shared by all temp/output files
SamHeader header = reader.GetHeader();
header.SortOrder = ( m_settings->IsSortingByName
? Constants::SAM_HD_SORTORDER_QUERYNAME
: Constants::SAM_HD_SORTORDER_COORDINATE );
m_headerText = header.ToString();
m_references = reader.GetReferenceData();
// set up alignments buffer
BamAlignment al;
vector<BamAlignment> buffer;
buffer.reserve( (size_t)(m_settings->MaxBufferCount*1.1) );
bool bufferFull = false;
// if sorting by name, we need to generate full char data
// so can't use GetNextAlignmentCore()
if ( m_settings->IsSortingByName ) {
// iterate through file
while ( reader.GetNextAlignment(al)) {
// check buffer's usage
bufferFull = ( buffer.size() >= m_settings->MaxBufferCount );
// store alignments until buffer is "full"
if ( !bufferFull )
buffer.push_back(al);
// if buffer is "full"
else {
// push any unmapped reads into buffer,
// don't want to split these into a separate temp file
if ( !al.IsMapped() )
buffer.push_back(al);
// "al" is mapped, so create a sorted temp file with current buffer contents
// then push "al" into fresh buffer
else {
CreateSortedTempFile(buffer);
buffer.push_back(al);
}
}
}
}
// sorting by position, can take advantage of GNACore() speedup
else {
// iterate through file
while ( reader.GetNextAlignmentCore(al) ) {
// check buffer's usage
bufferFull = ( buffer.size() >= m_settings->MaxBufferCount );
// store alignments until buffer is "full"
if ( !bufferFull )
buffer.push_back(al);
// if buffer is "full"
else {
// push any unmapped reads into buffer,
// don't want to split these into a separate temp file
if ( !al.IsMapped() )
buffer.push_back(al);
// "al" is mapped, so create a sorted temp file with current buffer contents
// then push "al" into fresh buffer
else {
CreateSortedTempFile(buffer);
buffer.push_back(al);
}
}
}
}
// handle any leftover buffer contents
if ( !buffer.empty() )
CreateSortedTempFile(buffer);
// close reader & return success
reader.Close();
return true;
}
void BamToFastq::PairedFastqUseTags() {
// open the 1st fastq file for writing
ofstream fq1(_fastq1.c_str(), ios::out);
if ( !fq1 ) {
cerr << "Error: The first fastq file (" << _fastq1 << ") could not be opened. Exiting!" << endl;
exit (1);
}
// open the 2nd fastq file for writing
ofstream fq2(_fastq2.c_str(), ios::out);
if ( !fq2 ) {
cerr << "Error: The second fastq file (" << _fastq2 << ") could not be opened. Exiting!" << endl;
exit (1);
}
// open the BAM file
BamReader reader;
reader.Open(_bamFile);
// rip through the BAM file and convert each mapped entry to BEDPE
BamAlignment bam1, bam2;
while (reader.GetNextAlignment(bam1)) {
reader.GetNextAlignment(bam2);
if (bam1.Name != bam2.Name) {
while (bam1.Name != bam2.Name)
{
if (bam1.IsPaired())
{
cerr << "*****WARNING: Query " << bam1.Name
<< " is marked as paired, but it's mate does not occur"
<< " next to it in your BAM file. Skipping. " << endl;
}
bam1 = bam2;
reader.GetNextAlignment(bam2);
}
}
else if (bam1.IsPaired() && bam2.IsPaired()) {
// assume the R2 and Q2 tags are on the + strand.
string mateSequence, mateQualities;
bam1.GetTag("R2", mateSequence);
bam1.GetTag("Q2", mateQualities);
string seq1 = bam1.QueryBases;
string qual1 = bam1.Qualities;
if (bam1.IsReverseStrand() == true) {
reverseComplement(seq1);
reverseSequence(qual1);
}
// since the info for both ends are contained in each BAM record,
// we only need to process one of the two records (bam1) in order
// to produce FASTQ entries for both ends.
// NOTE: Assumes that R2 and Q2 have already been rev
// and revcomped if necessary
if (bam1.IsFirstMate() == true) {
// end1
fq1 << "@" << bam1.Name << "/1" << endl;
fq1 << seq1 << endl;
fq1 << "+" << endl;
fq1 << qual1 << endl;
// end2
fq2 << "@" << bam1.Name << "/2" <<endl;
fq2 << mateSequence << endl;
fq2 << "+" << endl;
fq2 << mateQualities << endl;
}
else {
// end 2
fq2 << "@" << bam1.Name << "/2" <<endl;
fq2 << seq1 << endl;
fq2 << "+" << endl;
fq2 << qual1 << endl;
// end 1
fq1 << "@" << bam1.Name << "/1" <<endl;
fq1 << mateSequence << endl;
fq1 << "+" << endl;
fq1 << mateQualities << endl;
}
}
}
reader.Close();
}
int main (int argc, const char *argv[])
{
printf ("------------- bamrealignment --------------\n");
OptArgs opts;
opts.ParseCmdLine(argc, argv);
vector<int> score_vals(4);
string input_bam = opts.GetFirstString ('i', "input", "");
string output_bam = opts.GetFirstString ('o', "output", "");
opts.GetOption(score_vals, "4,-6,-5,-2", 's', "scores");
int clipping = opts.GetFirstInt ('c', "clipping", 2);
bool anchors = opts.GetFirstBoolean ('a', "anchors", true);
int bandwidth = opts.GetFirstInt ('b', "bandwidth", 10);
bool verbose = opts.GetFirstBoolean ('v', "verbose", false);
bool debug = opts.GetFirstBoolean ('d', "debug", false);
int format = opts.GetFirstInt ('f', "format", 1);
int num_threads = opts.GetFirstInt ('t', "threads", 8);
string log_fname = opts.GetFirstString ('l', "log", "");
if (input_bam.empty() or output_bam.empty())
return PrintHelp();
opts.CheckNoLeftovers();
std::ofstream logf;
if (log_fname.size ())
{
logf.open (log_fname.c_str ());
if (!logf.is_open ())
{
fprintf (stderr, "bamrealignment: Failed to open log file %s\n", log_fname.c_str());
return 1;
}
}
BamReader reader;
if (!reader.Open(input_bam)) {
fprintf(stderr, "bamrealignment: Failed to open input file %s\n", input_bam.c_str());
return 1;
}
SamHeader header = reader.GetHeader();
RefVector refs = reader.GetReferenceData();
BamWriter writer;
writer.SetNumThreads(num_threads);
if (format == 1)
writer.SetCompressionMode(BamWriter::Uncompressed);
else
writer.SetCompressionMode(BamWriter::Compressed);
if (!writer.Open(output_bam, header, refs)) {
fprintf(stderr, "bamrealignment: Failed to open output file %s\n", output_bam.c_str());
return 1;
}
// The meat starts here ------------------------------------
if (verbose)
cout << "Verbose option is activated, each alignment will print to screen." << endl
<< " After a read hit RETURN to continue to the next one," << endl
<< " or press q RETURN to quit the program," << endl
<< " or press s Return to silence verbose," << endl
<< " or press c RETURN to continue printing without further prompt." << endl << endl;
unsigned int readcounter = 0;
unsigned int mapped_readcounter = 0;
unsigned int realigned_readcounter = 0;
unsigned int modified_alignment_readcounter = 0;
unsigned int pos_update_readcounter = 0;
unsigned int failed_clip_realigned_readcount = 0;
unsigned int already_perfect_readcount = 0;
unsigned int bad_md_tag_readcount = 0;
unsigned int error_recreate_ref_readcount = 0;
unsigned int error_clip_anchor_readcount = 0;
unsigned int error_sw_readcount = 0;
unsigned int error_unclip_readcount = 0;
unsigned int start_position_shift;
int orig_position;
int new_position;
string md_tag, new_md_tag, input = "x";
vector<CigarOp> new_cigar_data;
vector<MDelement> new_md_data;
bool position_shift = false;
time_t start_time = time(NULL);
Realigner aligner;
aligner.verbose_ = verbose;
aligner.debug_ = debug;
if (!aligner.SetScores(score_vals))
cout << "bamrealignment: Four scores need to be provided: match, mismatch, gap open, gap extend score!" << endl;
aligner.SetAlignmentBandwidth(bandwidth);
BamAlignment alignment;
while(reader.GetNextAlignment(alignment)){
readcounter ++;
position_shift = false;
if ( (readcounter % 100000) == 0 )
cout << "Processed " << readcounter << " reads. Elapsed time: " << (time(NULL) - start_time) << endl;
if (alignment.IsMapped()) {
orig_position = alignment.Position;
mapped_readcounter++;
aligner.SetClipping(clipping, !alignment.IsReverseStrand());
if (aligner.verbose_) {
cout << endl;
if (alignment.IsReverseStrand())
cout << "The read is from the reverse strand." << endl;
else
cout << "The read is from the forward strand." << endl;
}
if (!alignment.GetTag("MD", md_tag)) {
if (aligner.verbose_)
cout << "Warning: Skipping read " << alignment.Name << ". It is mapped but missing MD tag." << endl;
if (logf.is_open ())
logf << alignment.Name << '\t' << alignment.IsReverseStrand() << '\t' << alignment.RefID << '\t' << setfill ('0') << setw (8) << orig_position << '\t' << "MISSMD" << '\n';
bad_md_tag_readcount++;
} else if (aligner.CreateRefFromQueryBases(alignment.QueryBases, alignment.CigarData, md_tag, anchors)) {
bool clipfail = false;
if (Realigner::CR_ERR_CLIP_ANCHOR == aligner.GetCreateRefError ())
{
clipfail = true;
failed_clip_realigned_readcount ++;
}
if (!aligner.computeSWalignment(new_cigar_data, new_md_data, start_position_shift)) {
if (aligner.verbose_)
cout << "Error in the alignment! Not updating read information." << endl;
if (logf.is_open ())
logf << alignment.Name << '\t' << alignment.IsReverseStrand() << '\t' << alignment.RefID << '\t' << setfill ('0') << setw (8) << orig_position << '\t' << "SWERR" << '\n';
error_sw_readcount++;
writer.SaveAlignment(alignment); // Write alignment unchanged
continue;
}
if (!aligner.addClippedBasesToTags(new_cigar_data, new_md_data, alignment.QueryBases.size())) {
if (aligner.verbose_)
cout << "Error when adding clipped anchors back to tags! Not updating read information." << endl;
if (logf.is_open ())
logf << alignment.Name << '\t' << alignment.IsReverseStrand() << '\t' << alignment.RefID << '\t' << setfill ('0') << setw (8) << orig_position << '\t' << "UNCLIPERR" << '\n';
writer.SaveAlignment(alignment); // Write alignment unchanged
error_unclip_readcount ++;
continue;
}
new_md_tag = aligner.GetMDstring(new_md_data);
realigned_readcounter++;
// adjust start position of read
if (!aligner.LeftAnchorClipped() and start_position_shift != 0) {
new_position = aligner.updateReadPosition(alignment.CigarData, (int)start_position_shift, alignment.Position);
if (new_position != alignment.Position) {
pos_update_readcounter++;
position_shift = true;
alignment.Position = new_position;
}
}
if (position_shift || alignment.CigarData.size () != new_cigar_data.size () || md_tag != new_md_tag)
{
if (logf.is_open ())
{
logf << alignment.Name << '\t' << alignment.IsReverseStrand() << '\t' << alignment.RefID << '\t' << setfill ('0') << setw (8) << orig_position << '\t' << "MOD";
if (position_shift)
logf << "-SHIFT";
if (clipfail)
logf << " NOCLIP";
logf << '\n';
}
modified_alignment_readcounter++;
}
else
{
if (logf.is_open ())
{
logf << alignment.Name << '\t' << alignment.IsReverseStrand() << '\t' << alignment.RefID << '\t' << setfill ('0') << setw (8) << orig_position << '\t' << "UNMOD";
if (clipfail)
logf << " NOCLIP";
logf << '\n';
}
}
if (aligner.verbose_){
cout << alignment.Name << endl;
cout << "------------------------------------------" << endl;
// Wait for input to continue or quit program
if (input.size() == 0)
input = 'x';
else if (input[0] != 'c' and input[0] != 'C')
getline(cin, input);
if (input.size()>0){
if (input[0] == 'q' or input[0] == 'Q')
return 1;
else if (input[0] == 's' or input[0] == 'S')
aligner.verbose_ = false;
}
}
// Finally update alignment information
alignment.CigarData = new_cigar_data;
alignment.EditTag("MD", "Z" , new_md_tag);
} // end of CreateRef else if
else {
switch (aligner.GetCreateRefError ())
{
case Realigner::CR_ERR_RECREATE_REF:
if (logf.is_open ())
logf << alignment.Name << '\t' << alignment.IsReverseStrand() << '\t' << alignment.RefID << '\t' << setfill ('0') << setw (8) << orig_position << '\t' << "RECRERR" << '\n';
error_recreate_ref_readcount++;
break;
case Realigner::CR_ERR_CLIP_ANCHOR:
if (logf.is_open ())
logf << alignment.Name << '\t' << alignment.IsReverseStrand() << '\t' << alignment.RefID << '\t' << setfill ('0') << setw (8) << orig_position << '\t' << "CLIPERR" << '\n';
error_clip_anchor_readcount++;
break;
default:
// On a good run this writes way too many reads to the log file - don't want to create a too large txt file
// if (logf.is_open ())
//logf << alignment.Name << '\t' << alignment.IsReverseStrand() << '\t' << alignment.RefID << '\t' << setfill ('0') << setw (8) << orig_position << '\t' << "PERFECT" << '\n';
already_perfect_readcount++;
break;
}
if (aligner.verbose_) {
cout << alignment.Name << endl;
cout << "------------------------------------------" << endl;
// Wait for input to continue or quit program
if (input.size() == 0)
input = 'x';
else if (input[0] != 'c' and input[0] != 'C')
getline(cin, input);
if (input.size()>0){
if (input[0] == 'q' or input[0] == 'Q')
return 1;
else if (input[0] == 's' or input[0] == 'S')
aligner.verbose_ = false;
}
}
}
// --- Debug output for Rajesh ---
if (debug && aligner.invalid_cigar_in_input) {
aligner.verbose_ = true;
cout << "Invalid cigar string / md tag pair in read " << alignment.Name << endl;
// Rerun reference generation to display error
aligner.CreateRefFromQueryBases(alignment.QueryBases, alignment.CigarData, md_tag, anchors);
aligner.verbose_ = verbose;
aligner.invalid_cigar_in_input = false;
}
// --- --- ---
} // end of if isMapped
writer.SaveAlignment(alignment);
} // end while loop over reads
if (aligner.invalid_cigar_in_input)
cerr << "WARNING bamrealignment: There were invalid cigar string / md tag pairs in the input bam file." << endl;
// ----------------------------------------------------------------
// program end -- output summary information
cout << " File: " << input_bam << endl
<< " Total reads: " << readcounter << endl
<< " Mapped reads: " << mapped_readcounter << endl;
if (bad_md_tag_readcount)
cout << " Skipped: bad MD tags: " << bad_md_tag_readcount << endl;
if (error_recreate_ref_readcount)
cout << " Skipped: unable to recreate ref: " << error_recreate_ref_readcount << endl;
if (error_clip_anchor_readcount)
cout << " Skipped: error clipping anchor: " << error_clip_anchor_readcount << endl;
cout << " Skipped: already perfect: " << already_perfect_readcount << endl
<< " Total reads realigned: " << mapped_readcounter - already_perfect_readcount - bad_md_tag_readcount - error_recreate_ref_readcount - error_clip_anchor_readcount << endl;
if (failed_clip_realigned_readcount)
cout << " (including " << failed_clip_realigned_readcount << " that failed to clip)" << endl;
if (error_sw_readcount)
cout << " Failed to complete SW alignment: " << error_sw_readcount << endl;
if (error_unclip_readcount)
cout << " Failed to unclip anchor: " << error_unclip_readcount << endl;
cout << " Succesfully realigned: " << realigned_readcounter << endl
<< " Modified alignments: " << modified_alignment_readcounter << endl
<< " Shifted position: " << pos_update_readcounter << endl;
cout << "Processing time: " << (time(NULL)-start_time) << " seconds." << endl;
cout << "INFO: The output BAM file may be unsorted." << endl;
cout << "------------------------------------------" << endl;
return 0;
}
void BedIntersect::IntersectBam(string bamFile) {
// load the "B" bed file into a map so
// that we can easily compare "A" to it for overlaps
_bedB = new BedFile(_bedBFile);
_bedB->loadBedFileIntoMap();
// create a dummy BED A file for printing purposes if not
// using BAM output.
if (_bamOutput == false) {
_bedA = new BedFile(_bedAFile);
_bedA->bedType = 12;
}
// open the BAM file
BamReader reader;
BamWriter writer;
reader.Open(bamFile);
// get header & reference information
string bamHeader = reader.GetHeaderText();
RefVector refs = reader.GetReferenceData();
// open a BAM output to stdout if we are writing BAM
if (_bamOutput == true) {
// set compression mode
BamWriter::CompressionMode compressionMode = BamWriter::Compressed;
if ( _isUncompressedBam ) compressionMode = BamWriter::Uncompressed;
writer.SetCompressionMode(compressionMode);
// open our BAM writer
writer.Open("stdout", bamHeader, refs);
}
vector<BED> hits;
// reserve some space
hits.reserve(100);
BamAlignment bam;
// get each set of alignments for each pair.
while (reader.GetNextAlignment(bam)) {
// save an unaligned read if -v
if (!bam.IsMapped()) {
if (_noHit == true)
writer.SaveAlignment(bam);
continue;
}
// break alignment into discrete blocks,
bedVector bed_blocks;
string chrom = refs.at(bam.RefID).RefName;
GetBamBlocks(bam, chrom, bed_blocks, false, true);
// create a basic BED entry from the BAM alignment
BED bed;
MakeBedFromBam(bam, chrom, bed_blocks, bed);
bool overlapsFound = false;
if ((_bamOutput == true) && (_obeySplits == false))
{
overlapsFound = _bedB->anyHits(bed.chrom, bed.start, bed.end,
bed.strand, _sameStrand, _diffStrand,
_overlapFraction, _reciprocal);
}
else if ( ((_bamOutput == true) && (_obeySplits == true)) ||
((_bamOutput == false) && (_obeySplits == true)) )
{
// find the hits that overlap with the full span of the blocked BED
_bedB->allHits(bed.chrom, bed.start, bed.end, bed.strand,
hits, _sameStrand, _diffStrand,
_overlapFraction, _reciprocal);
// find the overlaps between the block in A and B
overlapsFound = FindBlockedOverlaps(bed, bed_blocks, hits, _bamOutput);
}
else if ((_bamOutput == false) && (_obeySplits == false))
{
FindOverlaps(bed, hits);
}
// save the BAM alignment if overlap reqs. were met
if (_bamOutput == true) {
if ((overlapsFound == true) && (_noHit == false))
writer.SaveAlignment(bam);
else if ((overlapsFound == false) && (_noHit == true))
writer.SaveAlignment(bam);
}
hits.clear();
}
// close the relevant BAM files.
reader.Close();
if (_bamOutput == true) {
writer.Close();
}
}
int main (int argc, char *argv[]) {
if( (argc!= 3) ||
(argc== 2 && string(argv[1]) == "-h") ||
(argc== 2 && string(argv[1]) == "-help") ||
(argc== 2 && string(argv[1]) == "--help") ){
cerr<<"Usage:splitByRG [in bam] [out prefix]"<<endl<<"this program creates one bam file per RG in the with the outprefix\nFor example splitByRG in.bam out will create\nout.rg1.bam\nout.rg2.bam\n"<<endl;
return 1;
}
string bamfiletopen = string(argv[1]);
// if(!strEndsWith(bamfiletopen,".bam")){
// }
string bamDirOutPrefix = string(argv[2]);
map<string,BamWriter *> rg2BamWriter;
// if(!isDirectory(bamDirOut)){
// cerr<<"ERROR: the out directory does not exist"<<endl;
// return 1;
// }
BamReader reader;
if ( !reader.Open(bamfiletopen) ) {
cerr << "Could not open input BAM files." << endl;
return 1;
}
SamHeader header = reader.GetHeader();
const RefVector references = reader.GetReferenceData();
vector<RefData> refData=reader.GetReferenceData();
string pID = "splitByRG";
string pName = "splitByRG";
string pCommandLine = "";
for(int i=0;i<(argc);i++){
pCommandLine += (string(argv[i])+" ");
}
putProgramInHeader(&header,pID,pName,pCommandLine,returnGitHubVersion(string(argv[0]),".."));
SamReadGroupDictionary srgd=header.ReadGroups;
for(SamReadGroupConstIterator srgci=srgd.ConstBegin();
srgci<srgd.ConstEnd();
srgci++){
//cout<<*srgci<<endl;
const SamReadGroup rg = (*srgci);
//cout<<rg.ID<<endl;
rg2BamWriter[rg.ID] = new BamWriter();
rg2BamWriter[rg.ID]->Open(bamDirOutPrefix+"."+rg.ID+".bam",header,references);
}
BamAlignment al;
unsigned int total=0;
while ( reader.GetNextAlignment(al) ) {
// al.SetIsFailedQC(false);
// writer.SaveAlignment(al);
// if(al.IsMapped () ){
// if(rg2BamWriter.find(refData[al.RefID].RefName) == rg2BamWriter.end()){ //new
// rg2BamWriter[refData[al.RefID].RefName] = new BamWriter();
// if ( !rg2BamWriter[refData[al.RefID].RefName]->Open(bamDirOutPrefix+"."+refData[al.RefID].RefName+".bam",header,references) ) {
// cerr << "Could not open output BAM file "<< bamDirOutPrefix<<"."<<refData[al.RefID].RefName<<".bam" << endl;
// return 1;
// }
// }else{
// rg2BamWriter[refData[al.RefID].RefName]->SaveAlignment(al);
// }
// }else{
// unmapped.SaveAlignment(al);
// }
if(al.HasTag("RG")){
string rgTag;
al.GetTag("RG",rgTag);
//cout<<rgTag<<endl;
if(rg2BamWriter.find(rgTag) == rg2BamWriter.end()){ //new
cerr<<"Found new RG "<<rgTag<<endl;
rg2BamWriter[rgTag] = new BamWriter();
if ( !rg2BamWriter[rgTag]->Open(bamDirOutPrefix+"."+rgTag+".bam",header,references) ) {
cerr << "Could not open output BAM file "<< bamDirOutPrefix<<"."<<rgTag<<".bam" << endl;
return 1;
}
rg2BamWriter[rgTag]->SaveAlignment(al);
}else{
rg2BamWriter[rgTag]->SaveAlignment(al);
}
}else{
string rgTag="unknown";
//cout<<rgTag<<endl;
if(rg2BamWriter.find(rgTag) == rg2BamWriter.end()){ //new
cerr<<"Found new RG "<<rgTag<<endl;
rg2BamWriter[rgTag] = new BamWriter();
if ( !rg2BamWriter[rgTag]->Open(bamDirOutPrefix+"."+rgTag+".bam",header,references) ) {
cerr << "Could not open output BAM file "<< bamDirOutPrefix<<"."<<rgTag<<".bam" << endl;
return 1;
}
rg2BamWriter[rgTag]->SaveAlignment(al);
}else{
rg2BamWriter[rgTag]->SaveAlignment(al);
}
// cerr << "Cannot get RG tag for " << al.Name<<endl;
// return 1;
}
total++;
} //while al
reader.Close();
// writer.Close();
// unmapped.Close();
map<string,BamWriter *>::iterator rg2BamWriterIt;
for (rg2BamWriterIt =rg2BamWriter.begin();
rg2BamWriterIt!=rg2BamWriter.end();
rg2BamWriterIt++){
rg2BamWriterIt->second->Close();
}
cerr<<"Wrote succesfully "<<total<<" reads"<<endl;
return 0;
}
// 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;
}
}
void TagBam::Tag() {
// open the annotations files for processing;
OpenAnnoFiles();
// open the BAM file
BamReader reader;
BamWriter writer;
if (!reader.Open(_bamFile)) {
cerr << "Failed to open BAM file " << _bamFile << endl;
exit(1);
}
// get header & reference information
string bamHeader = reader.GetHeaderText();
RefVector refs = reader.GetReferenceData();
// set compression mode
BamWriter::CompressionMode compressionMode = BamWriter::Compressed;
// if ( _isUncompressedBam ) compressionMode = BamWriter::Uncompressed;
writer.SetCompressionMode(compressionMode);
// open our BAM writer
writer.Open("stdout", bamHeader, refs);
// rip through the BAM file and test for overlaps with each annotation file.
BamAlignment al;
vector<BED> hits;
while (reader.GetNextAlignment(al)) {
if (al.IsMapped() == true) {
BED a;
a.chrom = refs.at(al.RefID).RefName;
a.start = al.Position;
a.end = al.GetEndPosition(false, false);
a.strand = "+";
if (al.IsReverseStrand()) a.strand = "-";
ostringstream annotations;
// annotate the BAM file based on overlaps with the annotation files.
for (size_t i = 0; i < _annoFiles.size(); ++i)
{
// grab the current annotation file.
BedFile *anno = _annoFiles[i];
if (!_useNames && !_useScores && !_useIntervals) {
// add the label for this annotation file to tag if there is overlap
if (anno->anyHits(a.chrom, a.start, a.end, a.strand,
_sameStrand, _diffStrand, _overlapFraction, false))
{
annotations << _annoLabels[i] << ";";
}
}
// use the score field
else if (!_useNames && _useScores && !_useIntervals) {
anno->allHits(a.chrom, a.start, a.end, a.strand,
hits, _sameStrand, _diffStrand, 0.0, false);
for (size_t i = 0; i < hits.size(); ++i) {
annotations << hits[i].score;
if (i < hits.size() - 1) annotations << ",";
}
if (hits.size() > 0) annotations << ";";
hits.clear();
}
// use the name field from the annotation files to populate tag
else if (_useNames && !_useScores && !_useIntervals) {
anno->allHits(a.chrom, a.start, a.end, a.strand,
hits, _sameStrand, _diffStrand, 0.0, false);
for (size_t j = 0; j < hits.size(); ++j) {
annotations << hits[j].name;
if (j < hits.size() - 1) annotations << ",";
}
if (hits.size() > 0) annotations << ";";
hits.clear();
}
// use the full interval information annotation files to populate tag
else if (!_useNames && !_useScores && _useIntervals) {
anno->allHits(a.chrom, a.start, a.end, a.strand,
hits, _sameStrand, _diffStrand, 0.0, false);
for (size_t j = 0; j < hits.size(); ++j) {
annotations << _annoLabels[i] << ":" <<
hits[j].chrom << ":" <<
hits[j].start << "-" <<
hits[j].end << "," <<
hits[j].name << "," <<
hits[j].score << "," <<
hits[j].strand;
if (j < hits.size() - 1) annotations << ",";
}
if (hits.size() > 0) annotations << ";";
hits.clear();
}
}
// were there any overlaps with which to make a tag?
if (annotations.str().size() > 0) {
al.AddTag(_tag, "Z", annotations.str().substr(0, annotations.str().size() - 1)); // get rid of the last ";"
}
}
writer.SaveAlignment(al);
}
reader.Close();
writer.Close();
// close the annotations files;
CloseAnnoFiles();
}
