void HDFCmpExperimentGroup::AddQVs(const std::vector<UChar> &qualityValues,
const std::string &fieldName, unsigned int *offsetBegin,
unsigned int *offsetEnd)
{
std::vector<UChar> paddedQualityValues = qualityValues;
paddedQualityValues.push_back(0);
HDFArray<UChar> *arrayPtr = NULL;
// This seems to be how we do it
if (fieldName == "DeletionQV") {
arrayPtr = &deletionQV;
} else if (fieldName == "InsertionQV") {
arrayPtr = &insertionQV;
} else if (fieldName == "MergeQV") {
arrayPtr = &mergeQV;
} else if (fieldName == "SubstitutionQV") {
arrayPtr = &substitutionQV;
} else {
assert(false);
}
if (!arrayPtr->isInitialized) arrayPtr->Initialize(experimentGroup, fieldName);
*offsetBegin = arrayPtr->size();
*offsetEnd = arrayPtr->size() + qualityValues.size();
arrayPtr->Write(&paddedQualityValues[0], paddedQualityValues.size());
}
void StoreFrameRate(int movieIndex, float frameRate) {
if (movieIndex < 0) {
cout << "ERROR. Invalid movie index " << movieIndex << endl;
exit(1);
}
if (!frameRateArray.IsInitialized()) {
if (!movieInfoGroup.ContainsObject("FrameRate")) {
frameRateArray.Create(movieInfoGroup, "FrameRate");
}
else {
frameRateArray.Initialize(movieInfoGroup, "FrameRate");
}
}
frameRateArray.WriteToPos(&frameRate, 1, movieIndex);
}
int AddMovie(std::string &movieName)
{
nameArray.Write(&movieName, 1);
unsigned int id = nameArray.size();
idArray.Write(&id, 1);
return id;
}
bool Create(HDFGroup &parentGroup) {
parentGroup.AddGroup("MovieInfo");
if (movieInfoGroup.Initialize(parentGroup.group, "MovieInfo") == 0) { return 0; }
idArray.Create(movieInfoGroup, "ID");
nameArray.Create(movieInfoGroup, "Name");
return true;
}
void Read(MovieInfo &movieInfo) {
int nId = idArray.arrayLength;
movieInfo.id.resize(nId);
idArray.Read(0, nId, &movieInfo.id[0]);
int nName = nameArray.arrayLength;
movieInfo.name.resize(nName);
int i;
for (i = 0; i < nName; i++ ) {
nameArray.Read(i,i+1,&movieInfo.name[i]);
}
}
int Initialize(HDFGroup &parentGroup) {
if (movieInfoGroup.Initialize(parentGroup.group, "MovieInfo") == 0) {
return 0;
}
if (idArray.Initialize(movieInfoGroup, "ID") == 0) {
return 0;
}
if (nameArray.Initialize(movieInfoGroup, "Name") == 0) {
return 0;
}
return 1;
}
void HDFCmpExperimentGroup::AddTags(const std::vector<char> &qualityValues,
const std::string &fieldName, unsigned int *offsetBegin,
unsigned int *offsetEnd)
{
std::vector<char> paddedQualityValues = qualityValues;
paddedQualityValues.push_back(0);
HDFArray<char> *arrayPtr = NULL;
if (fieldName == "DeletionTag") {
arrayPtr = &deletionTag;
} else if (fieldName == "SubstitutionTag") {
arrayPtr = &substitutionTag;
} else {
assert(false);
}
if (!arrayPtr->isInitialized) arrayPtr->Initialize(experimentGroup, fieldName);
*offsetBegin = arrayPtr->size();
*offsetEnd = arrayPtr->size() + qualityValues.size();
arrayPtr->Write(&paddedQualityValues[0], paddedQualityValues.size());
}
void Read(CmpFile &cmpFile) {
ReadAlignmentDescriptions(cmpFile);
ReadStructure(cmpFile);
/*
* Now that the alignment indices are all read in, read the base-by-base alignments.
*/
unsigned int alignmentIndex;
for (alignmentIndex = 0; alignmentIndex < cmpFile.alnInfo.alignments.size(); alignmentIndex++) {
unsigned int alnGroupId = cmpFile.alnInfo.alignments[alignmentIndex].GetAlnGroupId();
unsigned int refGroupId = cmpFile.alnInfo.alignments[alignmentIndex].GetRefGroupId();
string refSeqName;
//
// Make sure the refGroupId specified in the alignment index exists in the alignment groups.
//
int refGroupArrayIndex;
if (refGroupIdToArrayIndex.find(refGroupId) == refGroupIdToArrayIndex.end()) {
cout << "ERROR! Alignment " << cmpFile.alnInfo.alignments[alignmentIndex].GetAlignmentId()
<< " has ref seq id " << refGroupId << " that does not exist in the HDF file." << endl;
assert(0);
}
else {
refGroupArrayIndex = refGroupIdToArrayIndex[refGroupId];
}
//
// Point to the refGroup that this alignment is part of.
//
HDFCmpRefAlignmentGroup* refAlignGroup = refAlignGroups[refGroupArrayIndex];
//
// Now locate the read group that is part of this ref align group.
//
string readGroupName = alnGroupIdToReadGroupName[alnGroupId];
if (refAlignGroup->experimentNameToIndex.find(readGroupName) ==
refAlignGroup->experimentNameToIndex.end()) {
cout << "Internal ERROR! The read group name " << readGroupName << " is specified as part of "
<< " the path in alignment " << cmpFile.alnInfo.alignments[alignmentIndex].GetAlignmentId()
<< " though it does not exist in the ref align group specified for this alignment." << endl;
assert(0);
}
int experimentIndex;
experimentIndex = refAlignGroup->experimentNameToIndex[readGroupName];
unsigned int alignmentLength = cmpFile.alnInfo.alignments[alignmentIndex].GetOffsetEnd() -
cmpFile.alnInfo.alignments[alignmentIndex].GetOffsetBegin();
vector<unsigned char> alignmentArray;
vector<float> fieldArray;
if (alignmentArray.size() < alignmentLength) {
alignmentArray.resize(alignmentLength);
}
/*
* Read in the base by base alignment.
*/
refAlignGroup->readGroups[experimentIndex]->alignmentArray.Read(cmpFile.alnInfo.alignments[alignmentIndex].GetOffsetBegin(),
cmpFile.alnInfo.alignments[alignmentIndex].GetOffsetEnd(),
&alignmentArray[0]);
cmpFile.alnInfo.alignments[alignmentIndex].StoreAlignmentArray(&alignmentArray[0], alignmentLength);
/*
* Read in all additional fields such as quality values, etc..
*/
set<string>::iterator fieldIt, fieldEnd;
fieldEnd = includedFields.end();
for (fieldIt = includedFields.begin(); fieldIt != fieldEnd; ++fieldIt) {
if (fieldArray.size() < alignmentLength) {
fieldArray.resize(alignmentLength);
}
HDFArray<float>* fieldArrayPtr = dynamic_cast<HDFArray<float>* >(refAlignGroup->readGroups[experimentIndex]->fields[*fieldIt]);
int ob = cmpFile.alnInfo.alignments[alignmentIndex].GetOffsetBegin();
int oe = cmpFile.alnInfo.alignments[alignmentIndex].GetOffsetEnd();
fieldArrayPtr->Read(ob, oe, &fieldArray[0]);
cmpFile.alnInfo.alignments[alignmentIndex].StoreFloatField(*fieldIt, &fieldArray[0], alignmentLength);
}
}
}
int GetNext(T_Sequence &ccsSequence) {
//
// Read in all ccs pass data.
//
ccsSequence.Free();
int retVal = 0;
if (this->curRead == ccsBasReader.nReads) {
return 0;
}
if (this->curBasePos == ccsBasReader.nBases) {
return 0;
}
try {
UInt numPasses;
numPassesArray.Read(this->curRead, this->curRead+1, &numPasses);
if (numPasses > 0) {
// Read in the ccs bases
if ((retVal = ccsBasReader.GetNext((SMRTSequence&)ccsSequence)) == 0)
return 0;
ccsSequence.numPasses = numPasses;
if (this->includedFields["AdapterHitAfter"]) {
ccsSequence.adapterHitAfter.resize(ccsSequence.numPasses);
adapterHitAfterArray.Read(curPassPos, curPassPos + ccsSequence.numPasses, &ccsSequence.adapterHitAfter[0]);
}
if (this->includedFields["AdapterHitBefore"]) {
ccsSequence.adapterHitBefore.resize(ccsSequence.numPasses);
adapterHitBeforeArray.Read(curPassPos, curPassPos + ccsSequence.numPasses, &ccsSequence.adapterHitBefore[0]);
}
if (this->includedFields["PassDirection"]) {
ccsSequence.passDirection.resize(ccsSequence.numPasses);
passDirectionArray.Read(curPassPos, curPassPos + ccsSequence.numPasses, &ccsSequence.passDirection[0]);
}
if (this->includedFields["PassNumBases"]) {
ccsSequence.passNumBases.resize(ccsSequence.numPasses);
passNumBasesArray.Read(curPassPos, curPassPos + ccsSequence.numPasses, &ccsSequence.passNumBases[0]);
}
if (this->includedFields["PassStartBase"]) {
ccsSequence.passStartBase.resize(ccsSequence.numPasses);
passStartBaseArray.Read(curPassPos, curPassPos + ccsSequence.numPasses, &ccsSequence.passStartBase[0]);
}
if (this->includedFields["PassStartPulse"]) {
ccsSequence.passStartPulse.resize(ccsSequence.numPasses);
passStartPulseArray.Read(curPassPos, curPassPos + ccsSequence.numPasses, &ccsSequence.passStartPulse[0]);
}
if (this->includedFields["PassNumPulses"]) {
ccsSequence.passNumPulses.resize(ccsSequence.numPasses);
passNumPulsesArray.Read(curPassPos, curPassPos + ccsSequence.numPasses, &ccsSequence.passNumPulses[0]);
}
curPassPos += ccsSequence.numPasses;
}
else {
// advance a read in the ccs sequence without advancing positions.
ccsBasReader.curRead++;
}
//
// Regardless whether or not a ccs read was called, read the next
// unrolled read, since an unrolled read is called for each zmw.
//
retVal = ((T_HDFBasReader<SMRTSequence>*)this)->GetNext(ccsSequence.unrolledRead);
ccsSequence.zmwData = ccsSequence.unrolledRead.zmwData;
ccsSequence.CopyTitle(ccsSequence.unrolledRead.title);
string newTitle = string(ccsSequence.title) + string("/ccs");
ccsSequence.CopyTitle(newTitle.c_str());
} catch (H5::DataSetIException e) {
cout << "ERROR, could not read ccs data for CCS Sequence "
<< ccsSequence.unrolledRead.title << endl;
exit(1);
}
// cout << "title: " << ccsSequence.title << endl;
if (retVal == 0) {
return 0;
}
else {
return 1;
}
}
unsigned int GetNumPasses(int readIndex) {
unsigned int numPasses;
numPassesArray.Read(readIndex, readIndex+1, &numPasses);
return numPasses;
}
