bio-velvet_underground 0.0.1

data/ext/src/src/binarySequences.h

@@ -0,0 +1,125 @@
+/*
+Copyright 2011 Convey Computer Corporation (info@conveycomputer.com)
+
+    This file is part of Velvet.
+
+    Velvet is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    Velvet is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Velvet; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+#ifndef _BINARYSEQUENCES_H_
+#define _BINARYSEQUENCES_H_
+
+#include "recycleBin.h"
+
+struct refInfo_st {
+	int32_t         m_referenceID;
+	int32_t         m_pos;
+};
+typedef struct refInfo_st RefInfo;
+
+
+typedef struct {
+	Category	m_numCategories;
+	uint32_t	m_magic;
+	boolean		m_bDoubleStrand;
+	boolean		m_bColor;
+	uint64_t	m_sequenceCnt;
+	uint64_t	m_timeStamp;
+	uint64_t	m_seqNuclStoreSize;
+	uint64_t	m_minSeqLen;
+	uint64_t	m_maxSeqLen;
+	uint64_t	m_totalSeqLen;
+	boolean		m_bFileWriteCompleted;
+} CnyUnifiedSeqFileHeader;
+
+// Reading
+struct sequencesReader_st {
+	char *		m_seqFilename;
+        FILE *		m_pFile;
+	ReadSet *       m_sequences;
+	boolean		m_bIsBinary;
+	// following are only used by the binary code
+	char *		m_namesFilename;
+        CnyUnifiedSeqFileHeader m_unifiedSeqFileHeader;
+	Category	m_numCategories;
+	Category	m_currCategory;
+	uint64_t	m_minSeqLen;
+	uint64_t	m_maxSeqLen;
+	uint8_t *	m_pReadBuffer;
+	uint8_t *	m_pReadBufEnd;
+	uint64_t	m_readBufPos;
+	uint8_t *	m_pCurrentReadPtr;
+	uint8_t *	m_pNextReadPtr;
+	uint64_t	m_currentNuclReadIdx;
+	uint64_t	m_currentReadLength;
+	uint32_t        m_refCnt;
+	boolean         m_bIsRef;
+	char **		m_ppCurrString;
+};
+
+#define USF_READ_BUF_SIZE				(64*1024)
+
+ReadSet *importCnyReadSet(char *filename);
+void getCnySeqNucl(SequencesReader *seqReadInfo, uint8_t *sequence);
+uint32_t readCnySeqUint32(SequencesReader *seqReadInfo);
+boolean advanceCnySeqCurrentRead(SequencesReader *seqReadInfo);
+FILE *openCnySeqForRead(const char *fileName, CnyUnifiedSeqFileHeader *seqFileHeader);
+void resetCnySeqCurrentRead(SequencesReader *seqReadInfo);
+
+struct refInfoList_st {
+	RefInfo		m_elem;
+	struct refInfoList_st *next;
+};
+typedef struct refInfoList_st RefInfoList;
+
+// Writing
+struct sequencesWriter_st {
+        FILE *		m_pFile;
+	// following are only used by the binary code
+	FILE *          m_nameFile;
+        CnyUnifiedSeqFileHeader m_unifiedSeqFileHeader;
+	uint64_t	m_insertStartIndex;
+	uint64_t	m_insertLength;
+	uint64_t	m_insertLengthIndex;
+	uint64_t	m_insertCurrentIndex;
+	uint32_t	m_hostBuffersInUse;
+	uint32_t	m_fileSegmentWriteIdx;
+	uint8_t	*	m_pWriteBuffer[3];
+	uint8_t *	m_pHostBufPtr;
+	uint8_t *	m_pHostLengthBufPtr;
+	uint8_t *	m_pHostLengthBufPtrMax;
+	uint8_t *	m_pHostBufPtrMax;
+	int64_t		m_hostBufferFilePos[3];
+	RefInfoList *	m_refInfoHead;
+	uint32_t        m_refCnt;
+	boolean         m_bIsRef;
+	Mask **         m_referenceMask;
+	Mask *          m_current;
+	Coordinate      m_position;
+	boolean         m_openMask;
+	RecycleBin *    m_maskMemory;
+};
+typedef struct sequencesWriter_st SequencesWriter;
+
+SequencesWriter * openCnySeqForWrite(const char *unifiedSeqFileName);
+void cnySeqInsertSequenceName(const char *name, IDnum readID, SequencesWriter *seqWriteInfo, Category cat);
+void cnySeqInsertReferenceMask(SequencesWriter *seqWriteInfo, Mask *referenceMask);
+void cnySeqInsertNucleotideString(const char *pReadBuf, SequencesWriter *seqWriteInfo);
+void inputCnySeqFileStart(Category category, SequencesWriter *seqWriteInfo);
+void cnySeqInsertStart(SequencesWriter *seqWriteInfo);
+void cnySeqInsertEnd(SequencesWriter *seqWriteInfo);
+void closeCnySeqForWrite(SequencesWriter *seqWriteInfo);
+
+#endif

data/ext/src/src/concatenatedGraph.c

@@ -0,0 +1,233 @@
+/*
+Copyright 2007, 2008 Daniel Zerbino (zerbino@ebi.ac.uk)
+
+    This file is part of Velvet.
+
+    Velvet is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    Velvet is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Velvet; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "globals.h"
+#include "graph.h"
+#include "passageMarker.h"
+#include "utility.h"
+
+// DEBUG
+static boolean isLocallyInitial(PassageMarkerI marker) {
+	PassageMarkerI previous = getPreviousInSequence(marker);
+	return (previous == NULL_IDX
+	    || getPassageMarkerFinish(previous) != getPassageMarkerStart(marker));
+}
+
+void concatenateReadStarts(Node * target, Node * source, Graph * graph)
+{
+	IDnum sourceLength, targetLength;
+	ShortReadMarker *sourceArray, *targetArray, *marker;
+	IDnum index;
+	Coordinate position, nodeLength;
+
+	if (!readStartsAreActivated(graph))
+		return;
+
+	if (target == NULL || source == NULL)
+		return;
+
+	// Update Coordinates
+	sourceArray = getNodeReads(source, graph);
+	sourceLength = getNodeReadCount(source, graph);
+
+	nodeLength = getNodeLength(target);
+	for (index = 0; index < sourceLength; index++) {
+		marker = getShortReadMarkerAtIndex(sourceArray, index);
+		position = getShortReadMarkerPosition(marker);
+		if (position != -1) {
+			position += nodeLength;
+			setShortReadMarkerPosition(marker, position);
+		}
+	}
+
+	// Same but for symmetrical reads
+	targetArray = getNodeReads(getTwinNode(target), graph);
+	targetLength = getNodeReadCount(getTwinNode(target), graph);
+
+	nodeLength = getNodeLength(source);
+	for (index = 0; index < targetLength; index++) {
+		marker = getShortReadMarkerAtIndex(targetArray, index);
+		position = getShortReadMarkerPosition(marker);
+		if (position != -1) {
+			position += nodeLength;
+			setShortReadMarkerPosition(marker, position);
+		}
+	}
+
+	// Merging lists
+	mergeNodeReads(target, source, graph);
+	mergeNodeReads(getTwinNode(target), getTwinNode(source), graph);
+}
+
+// Replaces two consecutive nodes into a single equivalent node
+// The extra memory is freed
+void concatenateStringOfNodes(Node * nodeA, Graph * graph)
+{
+	Node *twinA = getTwinNode(nodeA);
+	Node * nodeB = nodeA;
+	Node * twinB;
+	Node *currentNode, *nextNode;
+	Coordinate totalLength = 0;
+	PassageMarkerI marker, tmpMarker;
+	Arc *arc;
+
+	while (simpleArcCount(nodeB) == 1
+	       &&
+	       simpleArcCount(getTwinNode
+			      (getDestination(getArc(nodeB)))) ==
+	       1
+	       && getDestination(getArc(nodeB)) != getTwinNode(nodeB)
+	       && getDestination(getArc(nodeB)) != nodeA) {
+		totalLength += getNodeLength(nodeB);
+		nodeB = getDestination(getArc(nodeB));
+	}
+	twinB = getTwinNode(nodeB);
+	totalLength += getNodeLength(nodeB);
+	reallocateNodeDescriptor(nodeA, totalLength);
+
+	currentNode = nodeA;
+	while (currentNode != nodeB) {		
+		currentNode = getDestination(getArc(currentNode));
+
+		// Passage marker management in node A:
+		for (marker = getMarker(nodeA); marker != NULL_IDX;
+		     marker = getNextInNode(marker)) {
+ 			if (getNode(getNextInSequence(marker)) != currentNode 
+ 			    || getFinishOffset(marker) != 0
+ 			    || getStartOffset(getNextInSequence(marker)) != 0
+ 			    || getPassageMarkerFinish(marker) != getPassageMarkerStart(getNextInSequence(marker)))
+				incrementFinishOffset(marker,
+						      getNodeLength(currentNode));
+		}
+
+		// Swapping new born passageMarkers from B to A
+		for (marker = getMarker(currentNode); marker != NULL_IDX; marker = tmpMarker) {
+			tmpMarker = getNextInNode(marker);
+
+ 			if (isLocallyInitial(marker)
+ 			    || getNode(getPreviousInSequence(marker)) != nodeA
+ 			    || getStartOffset(marker) != 0
+ 			    || getFinishOffset(getPreviousInSequence(marker)) != 0
+ 			    || getPassageMarkerStart(marker) != getPassageMarkerFinish(getPreviousInSequence(marker))) {
+				extractPassageMarker(marker);
+				incrementFinishOffset(getTwinMarker(marker),
+						      getNodeLength(nodeA));
+				transposePassageMarker(marker, nodeA);
+			} else
+				disconnectNextPassageMarker(getPreviousInSequence
+							    (marker), graph);
+		}
+
+		// Read starts
+		concatenateReadStarts(nodeA, currentNode, graph);
+
+		// Gaps
+		appendNodeGaps(nodeA, currentNode, graph);
+
+		// Update uniqueness:
+		setUniqueness(nodeA, getUniqueness(nodeA) || getUniqueness(currentNode));
+
+#ifndef SINGLE_COV_CAT
+		Category cat;
+		for (cat = 0; cat < CATEGORIES; cat++) {
+			// Update virtual coverage
+			incrementVirtualCoverage(nodeA, cat,
+						 getVirtualCoverage(currentNode, cat));
+			// Update original virtual coverage
+			incrementOriginalVirtualCoverage(nodeA, cat,
+							 getOriginalVirtualCoverage(currentNode, cat));
+		}
+#else
+		// Update virtual coverage
+		incrementVirtualCoverage(nodeA, getVirtualCoverage(currentNode));
+#endif
+
+		// Descriptor management (node)
+		directlyAppendDescriptors(nodeA, currentNode, totalLength);
+	}
+
+	// Correct arcs
+	for (arc = getArc(nodeB); arc != NULL; arc = getNextArc(arc)) {
+		if (getDestination(arc) != twinB)
+			createAnalogousArc(nodeA, getDestination(arc),
+					   arc, graph);
+		else
+			createAnalogousArc(nodeA, twinA, arc, graph);
+	}
+
+	// Freeing gobbled nodes
+	currentNode = getTwinNode(nodeB);
+	while (currentNode != getTwinNode(nodeA)) {
+		arc = getArc(currentNode);
+		nextNode = getDestination(arc);
+		destroyNode(currentNode, graph);
+		currentNode = nextNode;
+	}
+}
+
+// Detects sequences that could be simplified through concatentation
+// Iterates till graph cannot be more simplified
+// Useless nodes are freed from memory and remaining ones are renumbered
+void concatenateGraph(Graph * graph)
+{
+	IDnum nodeIndex;
+	Node *node, *twin;
+
+	velvetLog("Concatenation...\n");
+
+	for (nodeIndex = 1; nodeIndex < nodeCount(graph); nodeIndex++) {
+		node = getNodeInGraph(graph, nodeIndex);
+
+		if (node == NULL)
+			continue;
+
+		twin = getTwinNode(node);
+		while (simpleArcCount(node) == 1
+		       &&
+		       simpleArcCount(getTwinNode
+				      (getDestination(getArc(node)))) ==
+		       1) {
+			if (getDestination(getArc(node)) == twin
+			    || getDestination(getArc(node)) == node)
+				break;
+			concatenateStringOfNodes(node,
+					 graph);
+		}
+
+		while (simpleArcCount(twin) == 1
+		       &&
+		       simpleArcCount(getTwinNode
+				      (getDestination(getArc(twin)))) ==
+		       1) {
+			if (getDestination(getArc(twin)) == node
+			    || getDestination(getArc(twin)) == twin)
+				break;
+			concatenateStringOfNodes(twin,
+					 graph);
+		}
+	}
+
+	renumberNodes(graph);
+	sortGapMarkers(graph);
+	velvetLog("Concatenation over!\n");
+}

data/ext/src/src/concatenatedGraph.h

@@ -0,0 +1,30 @@
+/*
+Copyright 2007, 2008 Daniel Zerbino (zerbino@ebi.ac.uk)
+
+    This file is part of Velvet.
+
+    Velvet is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    Velvet is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Velvet; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+#ifndef _CONCATENATEDGRAPH_H_
+#define _CONCATENATEDGRAPH_H_
+
+// Concatenates short read markers from node B to the end of nodeA 
+void concatenateReadStarts(Node * nodeA, Node * nodeB, Graph * graph);
+
+// Concatenates all pairs of nodes which form a linear structure
+void concatenateGraph(Graph * graph);
+
+#endif

data/ext/src/src/concatenatedPreGraph.c

@@ -0,0 +1,262 @@
+/*
+Copyright 2007, 2008 Daniel Zerbino (zerbino@ebi.ac.uk)
+
+    This file is part of Velvet.
+
+    Velvet is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    Velvet is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Velvet; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "globals.h"
+#include "preGraph.h"
+#include "utility.h"
+
+// Replaces two consecutive preNodes into a single equivalent preNode
+// The extra memory is freed
+static void concatenatePreNodes(IDnum preNodeAID, PreArcI oldPreArc,
+				PreGraph * preGraph)
+{
+	IDnum preNodeBID = preNodeAID;
+	IDnum currentPreNodeID, nextPreNodeID;
+	PreArcI preArc = oldPreArc;
+	Coordinate totalLength = 0;
+	Coordinate arrayLength;
+	Descriptor * descr, * ptr;
+	int writeOffset = 0;
+	int wordLength = getWordLength_pg(preGraph);
+	Coordinate totalOffset = 0;
+
+	//velvetLog("Concatenating nodes %li and %li\n", preNodeAID, preNodeBID);
+
+	while(hasSinglePreArc_pg(preNodeBID, preGraph)
+		       &&
+		       hasSinglePreArc_pg(getOtherEnd_pg
+					  (preArc, preNodeBID),
+					  preGraph)
+		       && !isLoop_pg(preArc) 
+		       && getDestination_pg(preArc, preNodeBID) != preNodeAID) {
+
+		totalLength += getPreNodeLength_pg(preNodeBID, preGraph);
+		preNodeBID = getDestination_pg(preArc, preNodeBID);
+		preArc = getPreArc_pg(preNodeBID, preGraph);
+	}
+	totalLength += getPreNodeLength_pg(preNodeBID, preGraph);
+	totalLength += wordLength - 1;
+
+	// Reference marker management
+	if (referenceMarkersAreActivated_pg(preGraph)) {
+		currentPreNodeID = preNodeAID;
+		preArc = getPreArc_pg(currentPreNodeID, preGraph);
+		for (currentPreNodeID = getDestination_pg(preArc, currentPreNodeID); currentPreNodeID != preNodeBID; currentPreNodeID = getDestination_pg(preArc, currentPreNodeID)) {
+			concatenateReferenceMarkers_pg(preNodeAID, currentPreNodeID, preGraph, totalOffset);
+			preArc = getPreArc_pg(currentPreNodeID, preGraph);
+			totalOffset += getPreNodeLength_pg(currentPreNodeID, preGraph);
+		}
+		concatenateReferenceMarkers_pg(preNodeAID, currentPreNodeID, preGraph, totalOffset);
+	}
+
+	// Descriptor management (preNode)
+	arrayLength = totalLength / 4;
+	if (totalLength % 4)
+		arrayLength++;
+	descr = callocOrExit(arrayLength, Descriptor);
+	ptr = descr;
+	if (preNodeAID > 0) {
+		currentPreNodeID = preNodeAID;
+		appendDescriptors_pg(&ptr, &writeOffset, currentPreNodeID, preGraph, true);
+		preArc = getPreArc_pg(currentPreNodeID, preGraph);
+		currentPreNodeID = getDestination_pg(preArc, currentPreNodeID);
+		while (currentPreNodeID != preNodeBID) {
+			appendDescriptors_pg(&ptr, &writeOffset, currentPreNodeID, preGraph, false);
+			preArc = getPreArc_pg(currentPreNodeID, preGraph);
+			currentPreNodeID = getDestination_pg(preArc, currentPreNodeID);
+		}
+		appendDescriptors_pg(&ptr, &writeOffset, currentPreNodeID, preGraph, false);
+	} else {
+		currentPreNodeID = -preNodeBID;
+		appendDescriptors_pg(&ptr, &writeOffset ,currentPreNodeID, preGraph, true);
+		preArc = getPreArc_pg(currentPreNodeID, preGraph);
+		currentPreNodeID = getDestination_pg(preArc, currentPreNodeID);
+		while (currentPreNodeID != -preNodeAID) {
+			appendDescriptors_pg(&ptr, &writeOffset ,currentPreNodeID, preGraph, false);
+			preArc = getPreArc_pg(currentPreNodeID, preGraph);
+			currentPreNodeID = getDestination_pg(preArc, currentPreNodeID);
+		}
+		appendDescriptors_pg(&ptr, &writeOffset ,currentPreNodeID, preGraph, false);
+	}
+
+	if (writeOffset != 0) 
+		while (writeOffset++ != 4)
+			(*ptr) >>= 2;
+
+	setPreNodeDescriptor_pg(descr, totalLength - wordLength + 1, preNodeAID, preGraph); 
+
+	// Correct preArcs
+	for (preArc = getPreArc_pg(preNodeBID, preGraph); preArc != NULL_IDX;
+	     preArc = getNextPreArc_pg(preArc, preNodeBID)) {
+		if (getDestination_pg(preArc, preNodeBID) != -preNodeBID)
+			createAnalogousPreArc_pg(preNodeAID,
+						 getDestination_pg(preArc,
+								   preNodeBID),
+						 preArc, preGraph);
+		else
+			createAnalogousPreArc_pg(preNodeAID, -preNodeAID,
+						 preArc, preGraph);
+	}
+
+	// Freeing gobbled preNode
+	currentPreNodeID = -preNodeBID;
+	while (currentPreNodeID != -preNodeAID) {
+		preArc = getPreArc_pg(currentPreNodeID, preGraph);
+		nextPreNodeID = getDestination_pg(preArc, currentPreNodeID);
+		destroyPreNode_pg(currentPreNodeID, preGraph);
+		currentPreNodeID = nextPreNodeID;
+	}
+}
+
+// Detects sequences that could be simplified through concatentation
+// Iterates till preGraph cannot be more simplified
+// Useless preNodes are freed from memory and remaining ones are renumbered
+void concatenatePreGraph_pg(PreGraph * preGraph)
+{
+	IDnum preNodeIndex;
+	PreArcI preArc;
+	PreNode *preNode;
+
+	velvetLog("Concatenation...\n");
+
+	for (preNodeIndex = 1; preNodeIndex < preNodeCount_pg(preGraph);
+	     preNodeIndex++) {
+		preNode = getPreNodeInPreGraph_pg(preGraph, preNodeIndex);
+
+		if (preNode == NULL)
+			continue;
+
+		preArc = getPreArc_pg(preNodeIndex, preGraph);
+
+		while (hasSinglePreArc_pg(preNodeIndex, preGraph)
+		       &&
+		       hasSinglePreArc_pg(getOtherEnd_pg
+					  (preArc, preNodeIndex),
+					  preGraph)) {
+			if (isLoop_pg(preArc))
+				break;
+			concatenatePreNodes(preNodeIndex, preArc,
+					    preGraph);
+			preArc = getPreArc_pg(preNodeIndex, preGraph);
+		}
+
+		preArc = getPreArc_pg(-preNodeIndex, preGraph);
+
+		while (hasSinglePreArc_pg(-preNodeIndex, preGraph)
+		       &&
+		       hasSinglePreArc_pg(getOtherEnd_pg
+					  (preArc, -preNodeIndex),
+					  preGraph)) {
+			if (isLoop_pg(preArc))
+				break;
+			concatenatePreNodes(-preNodeIndex, preArc,
+					    preGraph);
+			preArc = getPreArc_pg(-preNodeIndex, preGraph);
+		}
+	}
+
+	renumberPreNodes_pg(preGraph);
+	velvetLog("Concatenation over!\n");
+}
+
+static boolean isEligibleTip(IDnum index, PreGraph * preGraph, Coordinate
+			     cutoffLength)
+{
+	IDnum currentIndex = -index;
+	Coordinate totalLength = 0;
+	PreArcI activeArc = NULL_IDX;
+	PreArcI arc;
+	IDnum mult = 0;
+
+	if (getPreArc_pg(index, preGraph) != NULL_IDX)
+		return false;
+
+	// Finding first tangle
+	while (currentIndex != 0
+	       && simplePreArcCount_pg(-currentIndex, preGraph) < 2
+	       && simplePreArcCount_pg(currentIndex, preGraph) < 2
+	       && (!referenceMarkersAreActivated_pg(preGraph) || !hasPreMarkers(currentIndex, preGraph))) {
+		totalLength += getPreNodeLength_pg(currentIndex, preGraph);
+		activeArc = getPreArc_pg(currentIndex, preGraph);
+		currentIndex = getDestination_pg(activeArc, currentIndex);
+	}
+
+	// If too long
+	if (totalLength >= cutoffLength)
+		return false;
+
+	// If isolated snippet:
+	if (currentIndex == 0)
+		return true;
+
+	// Joined tips  
+	if (simplePreArcCount_pg(-currentIndex, preGraph) < 2)
+		return false;
+
+	// If unique event
+	if (getMultiplicity_pg(activeArc) == 1)
+		return true;
+
+	// Computing max arc
+	for (arc = getPreArc_pg(-currentIndex, preGraph); arc != NULL_IDX;
+	     arc = getNextPreArc_pg(arc, -currentIndex))
+		if (getMultiplicity_pg(arc) > mult)
+			mult = getMultiplicity_pg(arc);
+
+	// Testing for minority
+	return mult > getMultiplicity_pg(activeArc);
+}
+
+void clipTips_pg(PreGraph * preGraph)
+{
+	IDnum index;
+	PreNode *current;
+	boolean modified = true;
+	Coordinate cutoffLength = getWordLength_pg(preGraph) * 2;
+	IDnum counter = 0;
+
+	velvetLog("Clipping short tips off preGraph\n");
+
+	while (modified) {
+		modified = false;
+		for (index = 1; index <= preNodeCount_pg(preGraph);
+		     index++) {
+			current = getPreNodeInPreGraph_pg(preGraph, index);
+
+			if (current == NULL)
+				continue;
+
+			if (isEligibleTip(index, preGraph, cutoffLength)
+			    || isEligibleTip(-index, preGraph,
+					     cutoffLength)) {
+				counter++;
+				destroyPreNode_pg(index, preGraph);
+				modified = true;
+			}
+		}
+	}
+
+	concatenatePreGraph_pg(preGraph);
+	velvetLog("%li tips cut off\n", (long) counter);
+	velvetLog("%li nodes left\n", (long) preNodeCount_pg(preGraph));
+}