VarExprReturnSP LitMatrixExprReturn::convertToVarExprReturn( VarExprReturn &varExprReturn ) {
SFC::DT dt = getDT();
// assert( dt == varExprReturn.getDT() );
SFCTypesManager::DimensionVector dimensionVector = SFCTypesManager::getDimensions( dt );
if ( dimensionVector.empty() ) {
Exprs exprs = DE( getSequence().front() );
VarExprReturnSP varExprReturnSP = VarExprReturn::create( getBlock(), exprs, ExprsProxyVector(), SFCTypesManager::getSingleton().getBasicType( "double" ) );
varExprReturn.combine( "=", varExprReturnSP )->collapse();
return VarExprReturn::create( varExprReturn );
}
SFCTypesManager::DimensionVector countVector( dimensionVector.size(), 0 );
for( Sequence::iterator sqnItr = getSequence().begin() ; sqnItr != getSequence().end() ; ++sqnItr ) {
for( unsigned int ix = 0 ; ix < (unsigned int) dimensionVector.size() ; ++ix ) {
varExprReturn.getExprsProxyVector()[ ix ].setExprs( IE( countVector[ ix ] ) );
}
Exprs exprs = BE( varExprReturn.getExprs(), "=", DE( *sqnItr ) );
exprs.buildUdm( getBlock(), SFC::CompoundStatement::meta_stmnt );
for( int ix = dimensionVector.size() ; --ix >= 0 ;) {
if ( ++countVector[ix] < dimensionVector[ix] ) break;
countVector[ix] = 0;
}
}
return VarExprReturn::create( varExprReturn );
}
virtual void render(bool use_vbo) const
{
VL_CHECK(GLEW_VERSION_1_4);
VL_CHECK(!use_vbo || (use_vbo && (GLEW_ARB_vertex_buffer_object||GLEW_VERSION_1_5||GLEW_VERSION_3_0)))
use_vbo &= GLEW_ARB_vertex_buffer_object||GLEW_VERSION_1_5||GLEW_VERSION_3_0; // && indices()->gpuBuffer()->handle() && indices()->sizeGPU();
if ( !use_vbo && !indices()->size() )
return;
// apply patch parameters if any and if using PT_PATCHES
applyPatchParameters();
// primitive restart enable
if(primitiveRestartEnabled())
{
if(GLEW_VERSION_3_1)
{
glEnable(GL_PRIMITIVE_RESTART);
glPrimitiveRestartIndex(primitiveRestartIndex());
}
else
if(GLEW_NV_primitive_restart)
{
glEnable(GL_PRIMITIVE_RESTART_NV);
glPrimitiveRestartIndexNV(primitiveRestartIndex());
}
else
{
vl::Log::error("MultiDrawElements error: primitive restart not supported by this OpenGL implementation!\n");
VL_TRAP();
return;
}
}
GLvoid **indices_ptr = (GLvoid**)&mPointerVector[0];
if (use_vbo && indices()->gpuBuffer()->handle())
{
VL_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices()->gpuBuffer()->handle());
indices_ptr = (GLvoid**)&mNULLPointerVector[0];
}
else
VL_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (baseVertices().size())
{
VL_CHECK( baseVertices().size() == pointerVector().size() )
VL_CHECK( baseVertices().size() == countVector().size() )
if (GLEW_ARB_draw_elements_base_vertex || GLEW_VERSION_3_1)
glMultiDrawElementsBaseVertex(
primitiveType(), (GLsizei*)&mCountVector[0], indices()->glType(), indices_ptr, (GLsizei)mCountVector.size(), (GLint*)&mBaseVertices[0]
);
else
{
vl::Log::error("MultiDrawElements::render(): glMultiDrawElementsBaseVertex() not supported!\n"
"OpenGL 3.1 or GL_ARB_draw_elements_base_vertex extension required.\n"
);
}
}
// Correct a read with a k-mer based corrector
ErrorCorrectResult ErrorCorrectProcess::kmerCorrection(const SequenceWorkItem& workItem)
{
ErrorCorrectResult result;
typedef std::map<std::string, int> KmerCountMap;
KmerCountMap kmerCache;
SeqRecord currRead = workItem.read;
std::string readSequence = workItem.read.seq.toString();
#ifdef KMER_TESTING
std::cout << "Kmer correcting read " << workItem.read.id << "\n";
#endif
if((int)readSequence.size() < m_params.kmerLength)
{
// The read is shorter than the kmer length, nothing can be done
result.correctSequence = readSequence;
result.kmerQC = false;
return result;
}
int n = readSequence.size();
int nk = n - m_params.kmerLength + 1;
// Are all kmers in the read well-represented?
bool allSolid = false;
bool done = false;
int rounds = 0;
int maxAttempts = m_params.numKmerRounds;
// For each kmer, calculate the minimum phred score seen in the bases
// of the kmer
std::vector<int> minPhredVector(nk, 0);
for(int i = 0; i < nk; ++i)
{
int end = i + m_params.kmerLength - 1;
int minPhred = std::numeric_limits<int>::max();
for(int j = i; j <= end; ++j)
{
int ps = workItem.read.getPhredScore(j);
if(ps < minPhred)
minPhred = ps;
}
minPhredVector[i] = minPhred;
}
while(!done && nk > 0)
{
// Compute the kmer counts across the read
// and determine the positions in the read that are not covered by any solid kmers
// These are the candidate incorrect bases
std::vector<int> countVector(nk, 0);
std::vector<int> solidVector(n, 0);
for(int i = 0; i < nk; ++i)
{
std::string kmer = readSequence.substr(i, m_params.kmerLength);
// First check if this kmer is in the cache
// If its not, find its count from the fm-index and cache it
int count = 0;
KmerCountMap::iterator iter = kmerCache.find(kmer);
if(iter != kmerCache.end())
{
count = iter->second;
}
else
{
count = BWTAlgorithms::countSequenceOccurrencesWithCache(kmer, m_params.pOverlapper->getBWT(), m_params.pIntervalCache);
kmerCache.insert(std::make_pair(kmer, count));
}
// Get the phred score for the last base of the kmer
int phred = minPhredVector[i];
countVector[i] = count;
// std::cout << i << "\t" << phred << "\t" << count << "\n";
// Determine whether the base is solid or not based on phred scores
int threshold = CorrectionThresholds::Instance().getRequiredSupport(phred);
if(count >= threshold)
{
for(int j = i; j < i + m_params.kmerLength; ++j)
solidVector[j] = 1;
}
}
allSolid = true;
for(int i = 0; i < n; ++i)
{
#ifdef KMER_TESTING
std::cout << "Position[" << i << "] = " << solidVector[i] << "\n";
#endif
if(solidVector[i] != 1)
allSolid = false;
}
#ifdef KMER_TESTING
std::cout << "Read " << workItem.read.id << (allSolid ? " is solid\n" : " has potential errors\n");
#endif
// Stop if all kmers are well represented or we have exceeded the number of correction rounds
if(allSolid || rounds++ > maxAttempts)
break;
// Attempt to correct the leftmost potentially incorrect base
bool corrected = false;
for(int i = 0; i < n; ++i)
{
if(solidVector[i] != 1)
{
// Attempt to correct the base using the leftmost covering kmer
int phred = workItem.read.getPhredScore(i);
int threshold = CorrectionThresholds::Instance().getRequiredSupport(phred);
int left_k_idx = (i + 1 >= m_params.kmerLength ? i + 1 - m_params.kmerLength : 0);
corrected = attemptKmerCorrection(i, left_k_idx, std::max(countVector[left_k_idx], threshold), readSequence);
if(corrected)
break;
// base was not corrected, try using the rightmost covering kmer
size_t right_k_idx = std::min(i, n - m_params.kmerLength);
corrected = attemptKmerCorrection(i, right_k_idx, std::max(countVector[right_k_idx], threshold), readSequence);
if(corrected)
break;
}
}
// If no base in the read was corrected, stop the correction process
if(!corrected)
{
assert(!allSolid);
done = true;
}
}
if(allSolid)
{
result.correctSequence = readSequence;
result.kmerQC = true;
}
else
{
result.correctSequence = workItem.read.seq.toString();
result.kmerQC = false;
}
return result;
}
