// old mate-finding code, for position-sorted BAM files, didn't work well
BamAlignment
lookForMate(BamReader& rdr, BamAlignment& al, RefVector& refs)
{
if (! rdr.Jump(al.MateRefID, al.MatePosition)) {
cout << "*** Could not jump to " << al.MateRefID << ":" << al.MatePosition << endl;
exit(1);
}
BamAlignment al_jump;
while (rdr.GetNextAlignment(al_jump)) {
if (al_jump.Name == al.Name
&& al_jump.RefID == al.MateRefID
&& al_jump.Position == al.MatePosition) {
cout << "MATE FOUND" << endl;
printAlignmentInfo(al_jump, refs);
break;
} else if (al_jump.Position > al.MatePosition) {
cout << "NO MATE FOUND, beyond MatePosition" << endl;
break;
}
}
if (! rdr.Jump(al.RefID, al.Position)) {
cout << "*** Could not return to " << al.RefID << ":" << al.Position << endl;
exit(1);
}
// need to return to the read we were on after the jump, but how?
rdr.GetNextAlignment(al);
return(al_jump);
}
bool BamParse::loadIndex(BamReader& reader)
{
bool bsignal = reader.OpenIndex(this->filename_index);
if(bsignal==false)
{
cerr << "Index file not found, now create it!!!"<<endl;
bool bci=reader.CreateIndex();
if(bci==false)
{
cerr << "Index file cannot be created!!!"<<endl;
return false;
}
else
{
bool blct=reader.LocateIndex();
if(blct==false)
{
cerr << "Index file cannot be located!!!"<<endl;
return false;
}
}
}
return true;
}
/*
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;
}
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;
}
// 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;
}
// get next alignment among all files without parsing character data from alignments
bool BamMultiReader::GetNextAlignmentCore(BamAlignment& nextAlignment) {
// bail out if we are at EOF in all files, means no more alignments to process
if (!HasOpenReaders())
return false;
// when all alignments have stepped into a new target sequence, update our
// current reference sequence id
UpdateReferenceID();
// our lowest alignment and reader will be at the front of our alignment index
BamAlignment* alignment = alignments.begin()->second.second;
BamReader* reader = alignments.begin()->second.first;
// now that we have the lowest alignment in the set, save it by copy to our argument
nextAlignment = BamAlignment(*alignment);
//memcpy(&nextAlignment, alignment, sizeof(BamAlignment));
// remove this alignment index entry from our alignment index
alignments.erase(alignments.begin());
// and add another entry if we can get another alignment from the reader
if (reader->GetNextAlignmentCore(*alignment)) {
alignments.insert(make_pair(make_pair(alignment->RefID, alignment->Position),
make_pair(reader, alignment)));
} else { // do nothing
//cerr << "reached end of file " << lowestReader->GetFilename() << endl;
}
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;
}
}
// 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;
}
// close the BAM files
void BamMultiReader::Close(void) {
// close all BAM readers and clean up pointers
vector<pair<BamReader*, BamAlignment*> >::iterator readerIter = readers.begin();
vector<pair<BamReader*, BamAlignment*> >::iterator readerEnd = readers.end();
for ( ; readerIter != readerEnd; ++readerIter) {
BamReader* reader = (*readerIter).first;
BamAlignment* alignment = (*readerIter).second;
// close the reader
if ( reader) reader->Close();
// delete reader pointer
delete reader;
reader = 0;
// delete alignment pointer
delete alignment;
alignment = 0;
}
// clear out the container
readers.clear();
}
// 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;
}
bool BamMultiReaderPrivate::PopNextCachedAlignment(BamAlignment& al, const bool needCharData)
{
// skip if no alignments available
if (m_alignmentCache == 0 || m_alignmentCache->IsEmpty()) return false;
// pop next merge item entry from cache
MergeItem item = m_alignmentCache->TakeFirst();
BamReader* reader = item.Reader;
BamAlignment* alignment = item.Alignment;
if (reader == 0 || alignment == 0) return false;
// set char data if requested
if (needCharData) {
alignment->BuildCharData();
alignment->Filename = reader->GetFilename();
}
// store cached alignment into destination parameter (by copy)
al = *alignment;
// load next alignment from reader & store in cache
SaveNextAlignment(reader, alignment);
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();
}
// saves index data to BAM index files (".bai"/".bti") where necessary, returns success/fail
bool BamMultiReader::CreateIndexes(bool useStandardIndex) {
bool result = true;
for (vector<pair<BamReader*, BamAlignment*> >::iterator it = readers.begin(); it != readers.end(); ++it) {
BamReader* reader = it->first;
result &= reader->CreateIndex(useStandardIndex);
}
return result;
}
// returns BAM file pointers to beginning of alignment data
bool BamMultiReader::Rewind(void) {
bool result = true;
for (vector<pair<BamReader*, BamAlignment*> >::iterator it = readers.begin(); it != readers.end(); ++it) {
BamReader* reader = it->first;
result &= reader->Rewind();
}
return result;
}
/**
* 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 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 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;
}
void BamMultiReader::UpdateAlignments(void) {
// Update Alignments
alignments.clear();
for (vector<pair<BamReader*, BamAlignment*> >::iterator it = readers.begin(); it != readers.end(); ++it) {
BamReader* br = it->first;
BamAlignment* ba = it->second;
if (br->GetNextAlignment(*ba)) {
alignments.insert(make_pair(make_pair(ba->RefID, ba->Position),
make_pair(br, ba)));
} else {
// assume BamReader end of region / EOF
}
}
}
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 read_region_depth(const char* fn_tgt, BamReader& reader, vector<BamRegion>& regions, vector<unsigned int>& src_depths, vector<unsigned int>& tgt_depths) {
ifstream ifs;
string line, chr;
int chr_id, begin, end, src_dp, tgt_dp;
ifs.open(fn_tgt);
if (!ifs.is_open()) {
cerr << "ERROR: failed to open [" << fn_tgt << "]\n";
return 1;
}
while (getline(ifs, line)) {
stringstream linestream(line);
linestream >> chr >> begin >> end >> src_dp >> tgt_dp;
chr_id = reader.GetReferenceID(chr);
if (chr_id == -1) {
cerr << "WARNING: sequence [" << chr << "] not found in header, region [" << chr << ':' << begin << '-' << end << "] skipped\n";
}
else {
regions.push_back(BamRegion(chr_id, begin, chr_id, end));
src_depths.push_back(src_dp);
tgt_depths.push_back(tgt_dp);
}
}
cerr << "INFO: [" << regions.size() << "] regions read\n";
return 0;
}
::testing::AssertionResult CanRead(BamReader& reader, BamRecord& record, int i)
{
if (reader.GetNext(record))
return ::testing::AssertionSuccess() << "i: " << i;
else
return ::testing::AssertionFailure() << "i: " << i;
}
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;
}
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;
}
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();
}
}
// jumps to specified region(refID, leftBound) in BAM files, returns success/fail
bool BamMultiReader::Jump(int refID, int position) {
//if ( References.at(refID).RefHasAlignments && (position <= References.at(refID).RefLength) ) {
CurrentRefID = refID;
CurrentLeft = position;
bool result = true;
for (vector<pair<BamReader*, BamAlignment*> >::iterator it = readers.begin(); it != readers.end(); ++it) {
BamReader* reader = it->first;
result &= reader->Jump(refID, position);
if (!result) {
cerr << "ERROR: could not jump " << reader->GetFilename() << " to " << refID << ":" << position << endl;
exit(1);
}
}
if (result) UpdateAlignments();
return result;
}
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;
}
// ValidateReaders checks that all the readers point to BAM files representing
// alignments against the same set of reference sequences, and that the
// sequences are identically ordered. If these checks fail the operation of
// the multireader is undefined, so we force program exit.
void BamMultiReader::ValidateReaders(void) const {
int firstRefCount = readers.front().first->GetReferenceCount();
BamTools::RefVector firstRefData = readers.front().first->GetReferenceData();
for (vector<pair<BamReader*, BamAlignment*> >::const_iterator it = readers.begin(); it != readers.end(); ++it) {
BamReader* reader = it->first;
BamTools::RefVector currentRefData = reader->GetReferenceData();
BamTools::RefVector::const_iterator f = firstRefData.begin();
BamTools::RefVector::const_iterator c = currentRefData.begin();
if (reader->GetReferenceCount() != firstRefCount || firstRefData.size() != currentRefData.size()) {
cerr << "ERROR: mismatched number of references in " << reader->GetFilename()
<< " expected " << firstRefCount
<< " reference sequences but only found " << reader->GetReferenceCount() << endl;
exit(1);
}
// this will be ok; we just checked above that we have identically-sized sets of references
// here we simply check if they are all, in fact, equal in content
while (f != firstRefData.end()) {
if (f->RefName != c->RefName || f->RefLength != c->RefLength) {
cerr << "ERROR: mismatched references found in " << reader->GetFilename()
<< " expected: " << endl;
for (BamTools::RefVector::const_iterator a = firstRefData.begin(); a != firstRefData.end(); ++a)
cerr << a->RefName << " " << a->RefLength << endl;
cerr << "but found: " << endl;
for (BamTools::RefVector::const_iterator a = currentRefData.begin(); a != currentRefData.end(); ++a)
cerr << a->RefName << " " << a->RefLength << endl;
exit(1);
}
++f; ++c;
}
}
}
// 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;
}
bool BamMultiReaderPrivate::SetRegion(const BamRegion& region) {
// NB: While it may make sense to track readers in which we can
// successfully SetRegion, In practice a failure of SetRegion means "no
// alignments here." It makes sense to simply accept the failure,
// UpdateAlignments(), and continue.
// iterate over alignments
vector<MergeItem>::iterator readerIter = m_readers.begin();
vector<MergeItem>::iterator readerEnd = m_readers.end();
for ( ; readerIter != readerEnd; ++readerIter ) {
MergeItem& item = (*readerIter);
BamReader* reader = item.Reader;
if ( reader == 0 ) continue;
// set region of interest
reader->SetRegion(region);
}
// return status of cache update
return UpdateAlignmentCache();
}
// performs random-access jump using (refID, position) as a left-bound
bool BamMultiReaderPrivate::Jump(int refID, int position) {
// NB: While it may make sense to track readers in which we can
// successfully Jump, in practice a failure of Jump means "no
// alignments here." It makes sense to simply accept the failure,
// UpdateAlignments(), and continue.
// iterate over readers
vector<MergeItem>::iterator readerIter = m_readers.begin();
vector<MergeItem>::iterator readerEnd = m_readers.end();
for ( ; readerIter != readerEnd; ++readerIter ) {
MergeItem& item = (*readerIter);
BamReader* reader = item.Reader;
if ( reader == 0 ) continue;
// jump in each BamReader to position of interest
reader->Jump(refID, position);
}
// returns status of cache update
return UpdateAlignmentCache();
}
