Pileup< PILEUP_TYPE, FUNC_CLASS > Class Template Reference

Class to perform a pileup of all reads by position, assuming the reads are coordinate sorted. More...

#include <Pileup.h>

Collaboration diagram for Pileup< PILEUP_TYPE, FUNC_CLASS >:

[legend]

List of all members.

Public Member Functions
	Pileup (const FUNC_CLASS &fp=FUNC_CLASS())
	Constructor using the default maximum number of bases a read spans.
	Pileup (int window, const FUNC_CLASS &fp=FUNC_CLASS())
	Constructor that sets the maximum number of bases a read spans.
	Pileup (const std::string &refSeqFileName, const FUNC_CLASS &fp=FUNC_CLASS())
	Perform pileup with a reference.
	Pileup (int window, const std::string &refSeqFileName, const FUNC_CLASS &fp=FUNC_CLASS())
	Perform pileup with a reference and a specified window size.
virtual	~Pileup ()
	Destructor.
virtual int	processFile (const std::string &fileName, uint16_t excludeFlag=0x0704, uint16_t includeFlag=0)
	Performs a pileup on the specified file.
virtual void	processAlignment (SamRecord &record)
	Add an alignment to the pileup.
virtual void	processAlignmentRegion (SamRecord &record, int startPos, int endPos, PosList *excludeList=NULL)
	Add only positions that fall within the specified region of the alignment to the pileup and outside of the specified excluded positions.
void	flushPileup ()
	Done processing, flush every position that is currently being stored in the pileup.
Protected Member Functions
void	addAlignmentPosition (int refPosition, SamRecord &record)
virtual void	flushPileup (int refID, int refPosition)
void	flushPileup (int refPosition)
int	pileupPosition (int refPosition)
virtual void	resetElement (PILEUP_TYPE &element, int position)
virtual void	addElement (PILEUP_TYPE &element, SamRecord &record)
virtual void	analyzeElement (PILEUP_TYPE &element)
virtual void	analyzeHead ()
Protected Attributes
FUNC_CLASS	myAnalyzeFuncPtr
std::vector< PILEUP_TYPE >	myElements
int	pileupStart
int	pileupHead
int	pileupTail
int	pileupWindow
int	myCurrentRefID
GenomeSequence *	myRefPtr

---

Detailed Description

template<class PILEUP_TYPE, class FUNC_CLASS = defaultPileup<PILEUP_TYPE>>
class Pileup< PILEUP_TYPE, FUNC_CLASS >

Class to perform a pileup of all reads by position, assuming the reads are coordinate sorted.

Definition at line 58 of file Pileup.h.

---

Constructor & Destructor Documentation

template<class PILEUP_TYPE , class FUNC_CLASS>

Pileup< PILEUP_TYPE, FUNC_CLASS >::Pileup	(	int	window,
		const FUNC_CLASS &	fp = FUNC_CLASS()
	)			[inline]

Constructor that sets the maximum number of bases a read spans.

This is the "window" the length of the buffer that holds the pileups for each position until the read start has moved past the position.

Definition at line 168 of file Pileup.h.

    : myAnalyzeFuncPtr(fp),
      myElements(),
      pileupStart(0),
      pileupHead(0),
      pileupTail(-1),
      pileupWindow(window),
      myCurrentRefID(-2),
      myRefPtr(NULL)
{
    // Not using pointers since this is templated.
    myElements.resize(window);
}

---

Member Function Documentation

template<class PILEUP_TYPE , class FUNC_CLASS >

void Pileup< PILEUP_TYPE, FUNC_CLASS >::flushPileup

(

)

[inline]

Done processing, flush every position that is currently being stored in the pileup.

Definition at line 368 of file Pileup.h.

Referenced by Pileup< PILEUP_TYPE, FUNC_CLASS >::processAlignment(), Pileup< PILEUP_TYPE, FUNC_CLASS >::processAlignmentRegion(), Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile(), and Pileup< PILEUP_TYPE, FUNC_CLASS >::~Pileup().

{
    // while there are still entries between the head and tail, flush,
    // but no need to flush if pileupTail == -1 because in that case 
    // no entries have been added
    while ((pileupHead <= pileupTail) && (pileupTail != -1))
    {
        flushPileup(pileupHead+1);
    }
    pileupStart = pileupHead = 0;
    pileupTail = -1;
}

template<class PILEUP_TYPE , class FUNC_CLASS >

void Pileup< PILEUP_TYPE, FUNC_CLASS >::processAlignmentRegion	(	SamRecord &	record,
		int	startPos,
		int	endPos,
		PosList *	excludeList = NULL
	)			[inline, virtual]

Add only positions that fall within the specified region of the alignment to the pileup and outside of the specified excluded positions.

Parameters:

	record	alignment to be added to the pileup.
	startPos	0-based start position of the bases that should be added to the pileup.
	endPos	0-based end position of the bases that should be added to the pileup (this position is not added). Set to -1 if there is no end position to the region.
	excludeList	list of refID/positions to exclude from processing.

Definition at line 316 of file Pileup.h.

References Pileup< PILEUP_TYPE, FUNC_CLASS >::flushPileup(), SamRecord::get0BasedAlignmentEnd(), SamRecord::get0BasedPosition(), SamRecord::getReferenceID(), and PosList::hasPosition().

{
    int refPosition = record.get0BasedPosition();
    int refID = record.getReferenceID();

    // Flush any elements from the pileup that are prior to this record
    // since the file is sorted, we are done with those positions.
    flushPileup(refID, refPosition);
    
    // Check if the region starts after this reference starts.  If so,
    // we only want to start adding at the region start position.
    if(startPos > refPosition)
    {
        refPosition = startPos;
    }

    // Loop through for each reference position covered by the record.
    // It is up to the PILEUP_TYPE to handle insertions/deletions, etc
    // that are related with the given reference position.
    for(; refPosition <= record.get0BasedAlignmentEnd(); ++refPosition)
    {
        // Check to see if we have gone past the end of the region, in which
        // case we can stop processing this record.  Check >= since the
        // end position is not in the region.
        if((endPos != -1) && (refPosition >= endPos))
        {
            break;
        }

        // Check to see if this position is in the exclude list.
        bool addPos = true;
        if(excludeList != NULL)
        {
            // There is an exclude list, so lookup the position.
            if(excludeList->hasPosition(refID, refPosition))
            {
                // This position is in the exclude list, so don't add it.
                addPos = false;
            }
        }
        if(addPos)
        {
            addAlignmentPosition(refPosition, record);
        }
    }
}

template<class PILEUP_TYPE , class FUNC_CLASS >

int Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile	(	const std::string &	fileName,
		uint16_t	excludeFlag = 0x0704,
		uint16_t	includeFlag = 0
	)			[inline, virtual]

Performs a pileup on the specified file.

Parameters:

	excludeFlag	if specified, if any bit set in the exclude flag is set in the record's flag, it will be dropped. Defaulted to exclude: unmapped, not primary alignment failed platform/vendor quality check PCR or optical duplicate
	includeFlag	if specified, every bit must be set in the record's flag for it to be included - defaulted to 0, no bits are required to be set.

Returns:

0 for success and non-zero for failure.

Definition at line 235 of file Pileup.h.

References SamFile::COORDINATE, Pileup< PILEUP_TYPE, FUNC_CLASS >::flushPileup(), SamRecord::getFlag(), SamFile::GetStatus(), SamFile::GetStatusMessage(), StatGenStatus::NO_MORE_RECS, SamFile::OpenForRead(), Pileup< PILEUP_TYPE, FUNC_CLASS >::processAlignment(), SamFile::ReadHeader(), SamFile::ReadRecord(), SamFile::SetReference(), and SamFile::setSortedValidation().

{
    SamFile samIn;
    SamFileHeader header;
    SamRecord record;
    
    if(myRefPtr != NULL)
    {
        samIn.SetReference(myRefPtr);
    }

    if(!samIn.OpenForRead(fileName.c_str()))
    {
        fprintf(stderr, "%s\n", samIn.GetStatusMessage());
        return(samIn.GetStatus());
    }
    
    if(!samIn.ReadHeader(header))
    {
        fprintf(stderr, "%s\n", samIn.GetStatusMessage());
        return(samIn.GetStatus());
    }

    // The file needs to be sorted by coordinate.
    samIn.setSortedValidation(SamFile::COORDINATE);

    // Iterate over all records
    while (samIn.ReadRecord(header, record))
    {
        uint16_t flag = record.getFlag();
        if(flag & excludeFlag)
        {
            // This record has an excluded flag set, 
            // so continue to the next one.
            continue;
        }
        if((flag & includeFlag) != includeFlag)
        {
            // This record does not have all required flags set, 
            // so continue to the next one.
            continue;
        }
        processAlignment(record);
    }

    flushPileup();

    int returnValue = 0;
    if(samIn.GetStatus() != SamStatus::NO_MORE_RECS)
    {
        // Failed to read a record.
        fprintf(stderr, "%s\n", samIn.GetStatusMessage());
        returnValue = samIn.GetStatus();
    }
    return(returnValue);  
}

---

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

• bam/Pileup.h