finishm 0.0.1

data/ext/src/src/recycleBin.h

@@ -0,0 +1,58 @@
+/*
+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
+
+*/
+/****************************************************************\
+*                                                                *
+*  Efficient Memory Allocation Routines                          *
+*                                                                *
+*  Guy St.C. Slater..   mailto:guy@ebi.ac.uk                     *
+*  Copyright (C) 2000-2005.  All Rights Reserved.                *
+*                                                                *
+*  This source code is distributed under the terms of the        *
+*  GNU Lesser General Public License. See the file COPYING       *
+*  or http://www.fsf.org/copyleft/lesser.html for details        *
+*                                                                *
+*  If you use this code, please keep this notice intact.         *
+*                                                                *
+\****************************************************************/
+
+#ifndef INCLUDED_RECYCLEBIN_H
+#define INCLUDED_RECYCLEBIN_H
+
+typedef struct recycleBin_st RecycleBin;
+
+// Constructor, Destructor
+RecycleBin *newRecycleBin(size_t node_size, int nodes_per_chunk);
+void destroyRecycleBin(RecycleBin * recycle_bin);
+
+// Use
+void *allocatePointer(RecycleBin * recycle_bin);
+void deallocatePointer(RecycleBin * recycle_bin, void *data);
+
+#ifdef _OPENMP
+// For multithreading: thread-specific recycle bins
+RecycleBin *newRecycleBinArray(unsigned int n,
+			       size_t node_size, int nodes_per_chunk);
+void destroyRecycleBinArray(RecycleBin * recycle_bin);
+RecycleBin *getRecycleBinInArray(RecycleBin *recycleBin,
+				 int	     position);
+#endif
+
+#endif				/* INCLUDED_RECYCLEBIN_H */

data/ext/src/src/roadMap.c

@@ -0,0 +1,342 @@
+/*
+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 <string.h>
+#include <stdio.h>
+
+#include "globals.h"
+#include "graph.h"
+#include "recycleBin.h"
+#include "tightString.h"
+#include "roadMap.h"
+#include "utility.h"
+#include "kmer.h"
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+union positionPtr {
+	ShortLength coord;
+	IDnum nodeID;
+}  ATTRIBUTE_PACKED;
+
+struct annotation_st {
+	ShortLength position;	// 32
+	union positionPtr start;	// 32
+	union positionPtr finish;	// 32
+	ShortLength length;	// 32
+	IDnum sequenceID;	// 32
+}  ATTRIBUTE_PACKED;
+
+struct roadmap_st {
+	ShortLength annotationCount;
+}  ATTRIBUTE_PACKED;
+
+IDnum getAnnotationCount(RoadMap * rdmap)
+{
+	return rdmap->annotationCount;
+}
+
+Coordinate getFinish(Annotation * annot)
+{
+	return annot->finish.coord;
+}
+
+IDnum getAnnotSequenceID(Annotation * annot)
+{
+	return annot->sequenceID;
+}
+
+Coordinate getStart(Annotation * annot)
+{
+	return annot->start.coord;
+}
+
+Coordinate getPosition(Annotation * annot)
+{
+	return annot->position;
+}
+
+Coordinate getAnnotationLength(Annotation * annot)
+{
+	if (annot == NULL)
+		return 0;
+
+	return annot->length;
+}
+
+//////////////////////////////////////////////////////////////
+// Index conversion table
+//////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////
+
+// Imports roadmap from the appropriate file format
+// Memory allocated within the function
+RoadMapArray *importRoadMapArray(char *filename)
+{
+	FILE *file;
+	const int maxline = 100;
+	char *line = mallocOrExit(maxline, char);
+	RoadMap *rdmap = NULL;
+	IDnum seqID;
+	Coordinate position, start, finish;
+	Annotation *nextAnnotation;
+	RoadMapArray *result = mallocOrExit(1, RoadMapArray);
+	IDnum sequenceCount;
+	IDnum annotationCount = 0;
+	short short_var;
+	long long_var, long_var2;
+	long long longlong_var, longlong_var2, longlong_var3;
+	Coordinate *annotationOffset;
+	IDnum thisSeqID = 0;
+
+	velvetLog("Reading roadmap file %s\n", filename);
+
+	file = fopen(filename, "r");
+	if (!fgets(line, maxline, file))
+		exitErrorf(EXIT_FAILURE, true, "%s incomplete.", filename);
+	sscanf(line, "%ld\t%ld\t%i\t%hi\n", &long_var, &long_var2, &(result->WORDLENGTH), &short_var);
+	sequenceCount = (IDnum) long_var;
+	resetWordFilter(result->WORDLENGTH);
+	result->length = sequenceCount;
+	result->referenceCount = long_var2;
+	result->array = callocOrExit(sequenceCount, RoadMap);
+	result->double_strand = (boolean) short_var;
+
+	annotationOffset = callocOrExit(sequenceCount + 1, Coordinate);
+	while (fgets(line, maxline, file) != NULL)
+	{
+		if (line[0] != 'R')
+		{
+			annotationCount++;
+			annotationOffset[thisSeqID]++;
+		}
+		else
+		{
+		    	sscanf(line, "%*s %ld\n", &long_var);
+			thisSeqID = (IDnum) long_var;
+		}
+	}
+
+	result->annotations = callocOrExit(annotationCount, Annotation);
+	nextAnnotation = result->annotations;
+	fclose(file);
+
+	file = fopen(filename, "r");
+
+	// Cumulative sum
+	for (seqID = 1; seqID <= sequenceCount; seqID++)
+		annotationOffset[seqID] += annotationOffset[seqID - 1];
+
+	rdmap = result->array - 1;
+	if (!fgets(line, maxline, file))
+		exitErrorf(EXIT_FAILURE, true, "%s incomplete.", filename);
+	while (fgets(line, maxline, file) != NULL) {
+		if (line[0] == 'R') {
+		    	sscanf(line, "%*s %ld\n", &long_var);
+			thisSeqID = (IDnum) long_var;
+			nextAnnotation = result->annotations + annotationOffset[thisSeqID - 1];
+			rdmap = result->array + thisSeqID - 1;
+		} else {
+			sscanf(line, "%ld\t%lld\t%lld\t%lld\n", &long_var,
+			       &longlong_var, &longlong_var2, &longlong_var3);
+			seqID = (IDnum) long_var;
+			position = (Coordinate) longlong_var;
+			start = (Coordinate) longlong_var2;
+			finish = (Coordinate) longlong_var3;
+			nextAnnotation->sequenceID = seqID;
+			nextAnnotation->position = position;
+			nextAnnotation->start.coord = start;
+			nextAnnotation->finish.coord = finish;
+
+			if (seqID > 0)
+				nextAnnotation->length = finish - start;
+			else
+				nextAnnotation->length = start - finish;
+
+			rdmap->annotationCount++;
+			nextAnnotation++;
+		}
+	}
+	velvetLog("%li roadmaps read\n", (long)sequenceCount);
+
+	free (annotationOffset);
+	fclose(file);
+	free(line);
+	return result;
+}
+
+// Imports roadmap for matches to reference from the appropriate file format
+// Memory allocated within the function
+RoadMapArray *importReferenceRoadMapArray(char *filename)
+{
+	FILE *file;
+	const int maxline = 100;
+	char *line = mallocOrExit(maxline, char);
+	RoadMap *rdmap = NULL;
+	IDnum rdmapIndex = 0;
+	IDnum seqID;
+	Coordinate position, start, finish;
+	Annotation *nextAnnotation;
+	RoadMapArray *result = mallocOrExit(1, RoadMapArray);
+	IDnum sequenceCount;
+	IDnum annotationCount = 0;
+	short short_var;
+	long long_var, long_var2;
+	long long longlong_var, longlong_var2, longlong_var3;
+	Coordinate *annotationOffset;
+	IDnum thisSeqID = 0;
+
+	velvetLog("Reading roadmap file %s\n", filename);
+
+	file = fopen(filename, "r");
+	if (!fgets(line, maxline, file))
+		exitErrorf(EXIT_FAILURE, true, "%s incomplete.", filename);
+	sscanf(line, "%ld\t%ld\t%i\t%hi\n", &long_var, &long_var2, &(result->WORDLENGTH), &short_var);
+	sequenceCount = (IDnum) long_var;
+	resetWordFilter(result->WORDLENGTH);
+	result->length = sequenceCount;
+	result->referenceCount = long_var2;
+	result->array = callocOrExit(sequenceCount, RoadMap);
+	result->double_strand = (boolean) short_var;
+
+	annotationOffset = callocOrExit(sequenceCount + 1, Coordinate);
+	while (fgets(line, maxline, file) != NULL)
+	{
+		if (line[0] != 'R')
+		{
+			sscanf(line, "%ld\t%lld\t%lld\t%lld\n", &long_var,
+			       &longlong_var, &longlong_var2, &longlong_var3);
+			seqID = (IDnum) long_var;
+			if (seqID <= result->referenceCount && seqID >= -result->referenceCount)
+			{
+				annotationCount++;
+				annotationOffset[thisSeqID]++;
+			}
+		}
+		else
+		{
+		    	sscanf(line, "%*s %ld\n", &long_var);
+			thisSeqID = (IDnum) long_var;
+		}
+	}
+
+	result->annotations = callocOrExit(annotationCount, Annotation);
+	nextAnnotation = result->annotations;
+	fclose(file);
+
+	file = fopen(filename, "r");
+
+	// Cumulative sum
+	for (seqID = 1; seqID <= sequenceCount; seqID++)
+		annotationOffset[seqID] += annotationOffset[seqID - 1];
+
+	rdmap = result->array - 1;
+	if (!fgets(line, maxline, file))
+		exitErrorf(EXIT_FAILURE, true, "%s incomplete.", filename);
+	while (fgets(line, maxline, file) != NULL) {
+		if (line[0] == 'R') {
+		    	sscanf(line, "%*s %ld\n", &long_var);
+			thisSeqID = (IDnum) long_var;
+			nextAnnotation = result->annotations + annotationOffset[thisSeqID - 1];
+			rdmap = result->array + thisSeqID - 1;
+			rdmapIndex++;
+		} else {
+			sscanf(line, "%ld\t%lld\t%lld\t%lld\n", &long_var,
+			       &longlong_var, &longlong_var2, &longlong_var3);
+			seqID = (IDnum) long_var;
+			if (seqID <= result->referenceCount && seqID >= -result->referenceCount)
+			{
+				position = (Coordinate) longlong_var;
+				start = (Coordinate) longlong_var2;
+				finish = (Coordinate) longlong_var3;
+				nextAnnotation->sequenceID = seqID;
+				nextAnnotation->position = position;
+				nextAnnotation->start.coord = start;
+				nextAnnotation->finish.coord = finish;
+
+				if (seqID > 0)
+					nextAnnotation->length = finish - start;
+				else
+					nextAnnotation->length = start - finish;
+
+				rdmap->annotationCount++;
+				nextAnnotation++;
+			}
+		}
+	}
+
+	velvetLog("%li roadmaps references\n", (long) rdmapIndex);
+
+	free(annotationOffset);
+	fclose(file);
+	free(line);
+	return result;
+}
+
+RoadMap *getRoadMapInArray(RoadMapArray * array, IDnum index)
+{
+	return array->array + index;
+}
+
+void setStartID(Annotation * annot, IDnum nodeID)
+{
+	annot->start.nodeID = nodeID;
+}
+
+void setFinishID(Annotation * annot, IDnum nodeID)
+{
+	annot->finish.nodeID = nodeID;
+}
+
+IDnum getStartID(Annotation * annot)
+{
+	return annot->start.nodeID;
+}
+
+IDnum getFinishID(Annotation * annot)
+{
+	return annot->finish.nodeID;
+}
+
+void incrementAnnotationCoordinates(Annotation * annot)
+{
+	annot->start.coord++;
+	annot->finish.coord++;
+}
+
+Annotation *getNextAnnotation(Annotation * annot)
+{
+	return annot + 1;
+}
+
+Annotation *getAnnotationInArray(Annotation * annot, Coordinate index)
+{
+	return annot + index;
+}
+
+void destroyRoadMapArray(RoadMapArray * rdmaps) {
+	free(rdmaps->array);
+	free(rdmaps->annotations);
+	free(rdmaps);
+} 

data/ext/src/src/roadMap.h

@@ -0,0 +1,65 @@
+/*
+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 _ROADMAP_H_
+#define _ROADMAP_H_
+
+#include <stdio.h>
+
+struct roadMapArray_st {
+	RoadMap *array;
+	Annotation *annotations;
+	IDnum length;
+	int WORDLENGTH;
+	boolean double_strand;
+	IDnum referenceCount;
+};
+
+////////////////////////////////////////////////////////////////////
+//      Annotation stuff
+////////////////////////////////////////////////////////////////////
+IDnum getAnnotSequenceID(Annotation * annot);
+Coordinate getFinish(Annotation * annot);
+Coordinate getStart(Annotation * annot);
+Coordinate getPosition(Annotation * annot);
+Coordinate getAnnotationLength(Annotation * annot);
+void incrementAnnotationCoordinates(Annotation * annot);
+
+void setStartID(Annotation * annot, IDnum nodeID);
+IDnum getStartID(Annotation * annot);
+void setFinishID(Annotation * annot, IDnum nodeID);
+IDnum getFinishID(Annotation * annot);
+
+Annotation *getNextAnnotation(Annotation * annot);
+Annotation *getAnnotationInArray(Annotation * annot, Coordinate index);
+
+////////////////////////////////////////////////////////////////////
+//      RoadMap stuff
+////////////////////////////////////////////////////////////////////
+
+IDnum getAnnotationCount(RoadMap * rdmap);
+
+RoadMap *getRoadMapInArray(RoadMapArray * array, IDnum index);
+
+// Same thing but for the RoadMap file generated by the hash 
+RoadMapArray *importRoadMapArray(char *filename);
+RoadMapArray *importReferenceRoadMapArray(char * filename);
+void destroyRoadMapArray(RoadMapArray * rdmap); 
+#endif