bio-velvet_underground 0.0.1

data/ext/src/src/readSet.h

@@ -0,0 +1,67 @@
+/*
+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 _READSET_H_
+#define _READSET_H_
+
+struct readSet_st {
+	char **sequences;
+	TightString *tSequences;
+	char **labels;
+	char *tSeqMem;
+	Quality **confidenceScores;
+	Probability **kmerProbabilities;
+	IDnum *mateReads;
+	Category *categories;
+	unsigned char *secondInPair;
+	IDnum readCount;
+};
+
+struct mask_st {
+	Coordinate start;
+	Coordinate finish;
+	Mask* next;
+}; 
+
+ReadSet *newReadSet();
+
+ShortLength *getSequenceLengths(ReadSet * reads, int wordLength);
+
+void convertSequences(ReadSet * rs);
+
+ReadSet *importReadSet(char *filename);
+
+// The overall argument parser and file reader for the hash function
+void parseDataAndReadFiles(char * filename, int argc, char **argv, boolean * double_strand, boolean * noHash);
+
+void logInstructions(int argc, char **argv, char *directory);
+
+// Read pairing info
+void createReadPairingArray(ReadSet* reads);
+int pairedCategories(ReadSet * reads);
+boolean isSecondInPair(ReadSet * reads, IDnum index);
+void detachDubiousReads(ReadSet * reads, boolean * dubiousReads);
+
+void destroyReadSet(ReadSet * reads);
+
+boolean isCreateBinary();
+void setCreateBinary(boolean val);
+
+#endif

data/ext/src/src/recycleBin.c

@@ -0,0 +1,199 @@
+/*
+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.         *
+*                                                                *
+\****************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "globals.h"
+#include "recycleBin.h"
+#include "utility.h"
+
+typedef struct RecycleBin_Node {
+	struct RecycleBin_Node *next;
+} RecycleBin_Node;
+
+typedef struct chunk_st {
+	struct chunk_st *next;
+} Chunk;
+
+struct recycleBin_st {
+	Chunk *chunk_list;
+	RecycleBin_Node *recycle;
+	size_t node_size;
+	int chunk_pos;
+	int nodes_per_chunk;
+};
+
+static void initRecycleBin(RecycleBin *recycleBin,
+			   size_t node_size, int nodes_per_chunk)
+{
+	size_t chunckSize, allocSize;
+
+	chunckSize = sizeof(Chunk) + nodes_per_chunk * node_size;
+	allocSize = 1;
+	/* Get nearest power of 2 */
+	while (allocSize < chunckSize)
+		allocSize <<= 1;
+	nodes_per_chunk = (allocSize - sizeof(Chunk)) / node_size;
+	recycleBin->chunk_list = NULL;
+	recycleBin->chunk_pos = nodes_per_chunk;
+	recycleBin->nodes_per_chunk = nodes_per_chunk;
+	recycleBin->node_size = node_size;
+	recycleBin->recycle = NULL;
+}
+
+RecycleBin *newRecycleBin(size_t node_size, int nodes_per_chunk)
+{
+	RecycleBin *recycleBin;
+
+	if (node_size < sizeof(RecycleBin_Node)) {
+		velvetLog("Too small elements to create a recycle bin!\n");
+#ifdef DEBUG 
+		abort();
+#endif 
+		exit(-1);
+	}
+	recycleBin = mallocOrExit(1, RecycleBin);
+	initRecycleBin (recycleBin, node_size, nodes_per_chunk);
+
+	return recycleBin;
+}
+
+static void destroyRecycleBinChunks(RecycleBin * recycleBin)
+{
+	while (recycleBin->chunk_list != NULL)
+	{
+		Chunk *chunk;
+
+		chunk = recycleBin->chunk_list;
+		recycleBin->chunk_list = recycleBin->chunk_list->next;
+		free(chunk);
+	}
+}
+
+void destroyRecycleBin(RecycleBin * recycleBin)
+{
+	if (recycleBin == NULL)
+		return;
+
+	destroyRecycleBinChunks(recycleBin);
+	free(recycleBin);
+}
+
+void *allocatePointer(RecycleBin * recycle_bin)
+{
+	RecycleBin_Node *node;
+	Chunk *chunk;
+
+	if (recycle_bin == NULL) {
+		velvetLog("Null recycle bin!\n");
+#ifdef DEBUG 
+		abort();
+#endif 
+		exit(-1);
+	}
+
+	if (recycle_bin->recycle != NULL) {
+		node = recycle_bin->recycle;
+		recycle_bin->recycle = node->next;
+		return node;
+	}
+
+	if (recycle_bin->chunk_pos == recycle_bin->nodes_per_chunk) {
+		chunk = malloc(sizeof(Chunk) + recycle_bin->nodes_per_chunk
+			       * recycle_bin->node_size);
+		if (chunk == NULL) {
+			velvetLog("No more memory for memory chunk!\n");
+#ifdef DEBUG 
+			abort();
+#endif 
+			exit(-1);
+		}
+		chunk->next = recycle_bin->chunk_list;
+		recycle_bin->chunk_list = chunk;
+		recycle_bin->chunk_pos = 1;
+		return (RecycleBin_Node *) ((size_t) (void *) chunk +
+					    sizeof(Chunk));
+	}
+
+	chunk = recycle_bin->chunk_list;
+	return (RecycleBin_Node *) ((size_t) (void *) chunk + sizeof(Chunk)
+				    +
+				    (recycle_bin->
+				     node_size *
+				     recycle_bin->chunk_pos++));
+}
+
+void deallocatePointer(RecycleBin * recycle_bin, void *data)
+{
+	RecycleBin_Node *node = data;
+
+	node->next = recycle_bin->recycle;
+	recycle_bin->recycle = node;
+
+	return;
+}
+
+#ifdef _OPENMP
+RecycleBin *newRecycleBinArray(unsigned int n,
+			       size_t node_size, int nodes_per_chunk)
+{
+	RecycleBin *recycleBin;
+	int i;
+
+	recycleBin = mallocOrExit (n + 1, RecycleBin);
+	for (i = 0; i < n; i++)
+		initRecycleBin(recycleBin + i, node_size, nodes_per_chunk);
+	/* Last element marker */
+	recycleBin[n].node_size = 0;
+
+	return recycleBin;
+}
+
+void destroyRecycleBinArray(RecycleBin * recycleBin)
+{
+	int i;
+
+	for (i = 0; recycleBin[i].node_size != 0; i++)
+		destroyRecycleBinChunks(recycleBin + i);
+	free(recycleBin);
+}
+
+RecycleBin *getRecycleBinInArray(RecycleBin *recycleBin,
+				 int	     position)
+{
+	return recycleBin + position;
+}
+#endif

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);
+}