MatchAlignerTranslated Class Reference

#include <MatchAligner.h>

Inheritance diagram for MatchAlignerTranslated:

[legend]Collaboration diagram for MatchAlignerTranslated:

[legend]List of all members.

Public Member Functions
	MatchAlignerTranslated (int numCols, int bandExtension, bool isQueryProtein, bool isSubjectProtein, ostream &outputStream)
void	codonize (const char *pSeq, int seqSize, int finalFrame, vector< vector< char > > &translatedSeqs)
virtual void	createAlignment (Alignment &alignment, const char *pQuery, int queryStart, int queryEnd, const char *pSubject, int subjectStart, int subjectEnd)
Static Public Member Functions
static char	getCodon (const char *pChar)
Protected Attributes
bool	isQueryProtein_
bool	isSubjectProtein_

---

Detailed Description

Definition at line 297 of file MatchAligner.h.

---

Constructor & Destructor Documentation

MatchAlignerTranslated::MatchAlignerTranslated	(	int	numCols,
		int	bandExtension,
		bool	isQueryProtein,
		bool	isSubjectProtein,
		ostream &	outputStream
	)

Definition at line 525 of file MatchAligner.cpp.

                            :
  MatchAligner( numCols, 
                bandExtension,
                tableBlosum62_.getTable(), 
                outputStream ),
  isQueryProtein_(isQueryProtein),
  isSubjectProtein_(isSubjectProtein)
{

} // ~MatchAlignerTranslated::MatchAlignerTranslated

---

Member Function Documentation

void MatchAlignerTranslated::codonize	(	const char *	pSeq,
		int	seqSize,
		int	finalFrame,
		vector< vector< char > > &	translatedSeqs
	)

Definition at line 542 of file MatchAligner.cpp.

References gNumReadingFrames, gResidueNames, nv(), ttCodon, and ttDNA.

{
  translatedSeqs.resize(gNumReadingFrames);
  translatedSeqs[0].resize(seqSize);
  translatedSeqs[1].resize(seqSize - (finalFrame==0));
  translatedSeqs[2].resize(seqSize - (finalFrame!=2));
  //  cout << "codonizing: " << seqSize << endl;
  const char* pChar;
  vector<char>::iterator i;

  for (int j(0); j < gNumReadingFrames; j++ )
  {
    pChar = pSeq+j;
    for (i=translatedSeqs[j].begin(); 
         i!=translatedSeqs[j].end(); i++, 
         pChar+=gNumReadingFrames )
    {    
      //       cout << *pChar << *(pChar+1) << *(pChar+2) << endl;
      //  cout << int ( ttDNA[ *(pChar++ ] << 4
      //     | (ttDNA[ *(pChar++) ] << 2)
      //     | ttDNA[ *(pChar++) ] ) << endl; 
      if (    (ttDNA[ *(pChar)   ]==nv)
           || (ttDNA[ *(pChar+1) ]==nv)
           || (ttDNA[ *(pChar+2) ]==nv) )
      { 
        *i='X';
      } // ~if   
      else
      {
        *i= gResidueNames[ ttCodon[ ttDNA[ *(pChar) ] << 4
                                  | ttDNA[ *(pChar+1) ] << 2
                                  | ttDNA[ *(pChar+2) ] ] ];
      } // ~else

    } // ~for i

  } // ~for j

} // ~MatchAlignerTranslated::codonize

Here is the call graph for this function:

void MatchAlignerTranslated::createAlignment	(	Alignment &	alignment,
		const char *	pQuery,
		int	queryStart,
		int	queryEnd,
		const char *	pSubject,
		int	subjectStart,
		int	subjectEnd
	)			[virtual]

Reimplemented from MatchAligner.

Definition at line 587 of file MatchAligner.cpp.

References MatchAligner::bandExtension_, codonize(), PathMatrix< PATH_TYPE >::fillIn(), gNumReadingFrames, MatchAligner::pTable_, Alignment::totalScore_, and PathMatrix< PATH_TYPE >::traceBack().

{
  PathMatrix<PathType3D> path;

  int queryFinalFrame(0);
  int subjectFinalFrame(0);

  int querySize(queryEnd-queryStart+1);
  int subjectSize(subjectEnd-subjectStart+1);

  vector<vector<char> > queryTranslated;
  vector<vector<char> > subjectTranslated;
  const char* pQueryTrans[gNumReadingFrames] = 
  { pQuery, NULL, NULL };
  const char* pSubjectTrans[gNumReadingFrames] =
  { pSubject, NULL, NULL };

  //  AlignBreakType p1Gap, p2Gap;
  //  int p1FinalFrame, p2FinalFrame;
  bool p1IsQuery;


  if (!isQueryProtein_)
  {
    queryFinalFrame = querySize % gNumReadingFrames;
    querySize /= gNumReadingFrames;
    codonize( pQuery, querySize, queryFinalFrame, queryTranslated );
    queryTranslated[1].push_back(0);
    queryTranslated[2].push_back(0);
    pQueryTrans[0] = static_cast<const char*>(&*queryTranslated[0].begin());
    pQueryTrans[1] = static_cast<const char*>(&*queryTranslated[1].begin());
    pQueryTrans[2] = static_cast<const char*>(&*queryTranslated[2].begin());
  } // ~if

  if (!isSubjectProtein_)
  {
    subjectFinalFrame = subjectSize % gNumReadingFrames;
    subjectSize /= gNumReadingFrames;
    codonize( pSubject, subjectSize, subjectFinalFrame, subjectTranslated );
    subjectTranslated[1].push_back(0);
    subjectTranslated[2].push_back(0);
    pSubjectTrans[0]= static_cast<const char*>(&*subjectTranslated[0].begin());
    pSubjectTrans[1]= static_cast<const char*>(&*subjectTranslated[1].begin());
    pSubjectTrans[2]= static_cast<const char*>(&*subjectTranslated[2].begin());
  } // ~if

  if (querySize<=subjectSize)
  { // then p1 = query, p2 = subject
    p1IsQuery = true;
    ColumnFiller3D doMatrix( pQueryTrans, querySize, queryFinalFrame,
                             pSubjectTrans, subjectSize, subjectFinalFrame,
                             bandExtension_, *pTable_ ); 
    alignment.totalScore_ = path.fillIn(doMatrix);

  } // ~if
  else
  { // p1 = subject, p2 = query
    p1IsQuery = false;
    ColumnFiller3D doMatrix( pSubjectTrans, subjectSize, subjectFinalFrame,
                             pQueryTrans, querySize, queryFinalFrame,
                             bandExtension_, *pTable_ ); 
    alignment.totalScore_ = path.fillIn(doMatrix);

  } // ~else

  TraceBacker3D doCell( queryFinalFrame, subjectFinalFrame, 
                        p1IsQuery, alignment );
  path.traceBack(doCell); 
  //  path.traceBack(doCell, bandExtension_, 
  //     fabs(subjectSize-querySize)+bandExtension_); // 0 = band ext

  if (!isQueryProtein_)
  {
    queryTranslated[1].pop_back();
    queryTranslated[2].pop_back();
  }
  if (!isSubjectProtein_)
  {
    subjectTranslated[1].pop_back();
    subjectTranslated[2].pop_back();
  }

} // ~void MatchAlignerTranslated::createAlignment

Here is the call graph for this function:

static char MatchAlignerTranslated::getCodon

(

const char *

pChar

)

[inline, static]

Definition at line 316 of file MatchAligner.h.

References gResidueNames, nv(), ttCodon, and ttDNA.

  {
    return (  (    (ttDNA[ *pChar ] ==nv)
                   || (ttDNA[ *(pChar+1) ] ==nv)
                   || (ttDNA[ *(pChar+2) ] ==nv) )
              ? 'X'
              : gResidueNames[ ttCodon[ ttDNA[ *(pChar) ] << 4
                                      | ttDNA[ *(pChar+1) ] << 2
                                      | ttDNA[ *(pChar+2) ] ] ] );
  } // ~getCodon

Here is the call graph for this function:

---

Member Data Documentation

bool MatchAlignerTranslated::isQueryProtein_ [protected]

Definition at line 329 of file MatchAligner.h.

bool MatchAlignerTranslated::isSubjectProtein_ [protected]

Definition at line 330 of file MatchAligner.h.

---

The documentation for this class was generated from the following files:

• QueryManager/MatchAligner.h
• QueryManager/MatchAligner.cpp

---