bio-velvet_underground 0.0.1

data/ext/src/src/kmer.h

@@ -0,0 +1,73 @@
+/*
+Copyright 2007, 2008, 2009 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 _KMER_H_
+#define _KMER_H_
+
+#include <stdint.h>
+
+#include "globals.h"
+
+void copyKmers(Kmer* k1, Kmer* k2);
+
+void pushNucleotide(Kmer * kmer, Nucleotide nucleotide);
+Nucleotide popNucleotide(Kmer * kmer);
+
+int compareKmers(Kmer* k1, Kmer* k2);
+
+void reversePushNucleotide(Kmer * kmer, Nucleotide nucleotide);
+
+KmerKey getKmerKey(Kmer * kmer);
+
+void printKmer(Kmer * kmer);
+
+void clearKmer(Kmer * kmer);
+
+void resetWordFilter(int wordLength);
+void resetKeyFilter(int keyLength);
+
+#define KMER_QUOTIENT (MAXKMERLENGTH / 4)
+#define KMER_REMAINDER (MAXKMERLENGTH % 4)
+#if KMER_REMAINDER
+#define KMER_BYTE_SIZE (KMER_QUOTIENT + 1)
+#else
+#define KMER_BYTE_SIZE KMER_QUOTIENT
+#endif
+#define KMER_LONGLONGS (KMER_BYTE_SIZE / 8)
+#define KMER_LONGS ((KMER_BYTE_SIZE % 8) / 4)
+#define KMER_INTS ((KMER_BYTE_SIZE % 4) / 2)
+#define KMER_CHARS (KMER_BYTE_SIZE % 2)
+
+struct kmer_st {
+#if KMER_LONGLONGS
+	uint64_t longlongs[KMER_LONGLONGS];
+#endif
+#if KMER_LONGS
+	uint32_t longs;
+#endif
+#if KMER_INTS
+	uint16_t ints;
+#endif
+#if KMER_CHARS
+	uint8_t chars;
+#endif
+}  ATTRIBUTE_PACKED;
+
+#endif 

data/ext/src/src/kmerOccurenceTable.c

@@ -0,0 +1,236 @@
+/*
+Copyright 2010 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 <string.h>
+#include <limits.h>
+
+#include "globals.h"
+#include "graph.h"
+#include "passageMarker.h"
+#include "readSet.h"
+#include "tightString.h"
+#include "recycleBin.h"
+#include "utility.h"
+#include "kmer.h"
+
+// Internal structure used to mark the ends of an Annotation
+struct kmerOccurence_st {
+	IDnum position;
+	IDnum nodeID;
+	IDnum offset;
+	Kmer kmer;
+} ATTRIBUTE_PACKED;
+
+struct kmerOccurenceTable_st {
+	KmerOccurence *kmerTable;
+	KmerOccurence * kmerOccurencePtr;
+	IDnum *accelerationTable;
+	IDnum kmerTableSize;
+	IDnum kmerOccurenceIndex;
+	short int accelerationShift;
+	short int accelerationBits;
+};
+
+int compareKmerOccurences(void const *A, void const *B)
+{
+	KmerOccurence *a = (KmerOccurence *) A;
+	KmerOccurence *b = (KmerOccurence *) B;
+	return compareKmers(&(a->kmer), &(b->kmer));
+}
+
+static inline KmerKey keyInAccelerationTable(Kmer * kmer,
+					  KmerOccurenceTable * table)
+{
+	return getKmerKey(kmer);
+}
+
+KmerOccurence *findKmerInKmerOccurenceTable(Kmer * kmer,
+						     KmerOccurenceTable *
+						     table)
+{
+	KmerOccurence *array = table->kmerTable;
+	KmerKey key = keyInAccelerationTable(kmer, table);
+	Coordinate leftIndex, rightIndex, middleIndex;
+	int diff;
+
+	if (table->accelerationTable != NULL) {
+		leftIndex = table->accelerationTable[key];
+		rightIndex = table->accelerationTable[key + 1];
+	} else {
+		leftIndex = 0;
+		rightIndex = table->kmerTableSize;
+	}
+
+	while (true) {
+		middleIndex = (rightIndex + leftIndex) / 2;
+
+		if (leftIndex >= rightIndex)
+			return NULL;
+
+		diff = compareKmers(&(array[middleIndex].kmer), kmer);
+
+		if (diff == 0) {
+			middleIndex -= array[middleIndex].offset;
+			return &(array[middleIndex]);
+		} else if (leftIndex == middleIndex)
+			return NULL;
+		else if (diff > 0)
+			rightIndex = middleIndex;
+		else
+			leftIndex = middleIndex;
+	}
+}
+
+KmerOccurenceTable * newKmerOccurenceTable(short int accelerationBits, int wordLength) {
+	KmerOccurenceTable * kmerTable = mallocOrExit(1, KmerOccurenceTable);
+
+	if (accelerationBits > 2 * wordLength)
+		accelerationBits = 2 * wordLength;
+
+	if (accelerationBits > 32)
+		accelerationBits = 32;
+
+	if (accelerationBits > 0) {
+		resetKeyFilter(accelerationBits);	
+		kmerTable->accelerationBits = accelerationBits;
+		kmerTable->accelerationTable =
+		    callocOrExit((((size_t) 1) << accelerationBits) + 1,
+			   IDnum);
+		kmerTable->accelerationShift =
+		    (short int) 2 *wordLength - accelerationBits;
+	} else {
+		kmerTable->accelerationBits = 0;
+		kmerTable->accelerationTable = NULL;
+		kmerTable->accelerationShift = 0;
+	}
+
+	return kmerTable;
+}
+
+void allocateKmerOccurences(IDnum kmerCount, KmerOccurenceTable * table) {
+	KmerOccurence * kmerOccurences = callocOrExit(kmerCount + 1, KmerOccurence);
+	kmerOccurences[kmerCount].position = -1;
+	kmerOccurences[kmerCount].nodeID = 0;
+
+	table->kmerTable = kmerOccurences;
+	table->kmerTableSize = kmerCount;
+	table->kmerOccurencePtr = kmerOccurences;
+	table->kmerOccurenceIndex = 0;
+}
+
+void recordKmerOccurence(Kmer * kmer, IDnum nodeID, Coordinate position, KmerOccurenceTable * table) {
+	KmerOccurence * kmerOccurence;
+
+#ifdef _OPENMP
+	#pragma omp critical
+#endif 
+	{
+		kmerOccurence = table->kmerOccurencePtr++;
+		table->kmerOccurenceIndex++;
+	}
+
+	copyKmers(&(kmerOccurence->kmer), kmer);
+	kmerOccurence->nodeID = nodeID;
+	kmerOccurence->position = position;
+
+}
+
+void sortKmerOccurenceTable(KmerOccurenceTable * table) {
+	KmerKey lastHeader = 0;
+	KmerKey header;
+	IDnum *accelPtr = NULL;
+	IDnum kmerOccurenceIndex;
+	KmerOccurence * kmerOccurence, * previous;
+
+	velvetLog("Sorting kmer occurence table ... \n");
+
+	qsort(table->kmerTable, table->kmerTableSize, sizeof(KmerOccurence),
+	      compareKmerOccurences);
+
+	velvetLog("Sorting done.\n");
+
+	velvetLog("Computing acceleration table... \n");
+
+	// Fill up acceleration table
+	if (table->accelerationTable != NULL) {
+		accelPtr = table->accelerationTable;
+		*accelPtr = (IDnum) 0;
+		for (kmerOccurenceIndex = 0;
+		     kmerOccurenceIndex < table->kmerTableSize;
+		     kmerOccurenceIndex++) {
+			header =
+			    keyInAccelerationTable(&table->kmerTable
+						   [kmerOccurenceIndex].
+						   kmer, table);
+			while (lastHeader < header) {
+				lastHeader++;
+				accelPtr++;
+				*accelPtr = kmerOccurenceIndex;
+			}
+		}
+
+		while (lastHeader < (KmerKey) 1 << table->accelerationBits) {
+			lastHeader++;
+			accelPtr++;
+			*accelPtr = table->kmerTableSize;
+		}
+	}
+
+	velvetLog("Computing offsets... \n");
+
+	// Compute offsets
+	kmerOccurence = table->kmerTable;
+	previous = NULL;
+	for (kmerOccurenceIndex = 1;
+	     kmerOccurenceIndex < table->kmerTableSize;
+	     kmerOccurenceIndex++) {
+		if (previous && compareKmerOccurences(kmerOccurence, previous) == 0)
+			kmerOccurence->offset = previous->offset + 1;
+		previous = kmerOccurence;
+		kmerOccurence++;
+	}
+}
+
+KmerOccurence * getNextKmerOccurence(KmerOccurence * current) {
+	register KmerOccurence * next = current + 1;
+	if (next->nodeID == 0 || next->offset == 0)
+		return NULL;
+	else
+		return next;
+}
+
+void destroyKmerOccurenceTable(KmerOccurenceTable * kmerTable) {
+	if (kmerTable == NULL)
+		return; 
+
+	free(kmerTable->kmerTable);
+	free(kmerTable->accelerationTable);
+	free(kmerTable);
+}
+
+IDnum getKmerOccurenceNodeID(KmerOccurence * occurence) {
+	return occurence->nodeID;
+} 
+
+Coordinate getKmerOccurencePosition(KmerOccurence * occurence) {
+	return occurence->position;
+}

data/ext/src/src/kmerOccurenceTable.h

@@ -0,0 +1,44 @@
+/*
+Copyright 2010 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 _KMEROCCURENCETABLE_H_
+#define _KMEROCCURENCETABLE_H_
+
+// Table operations
+KmerOccurenceTable * newKmerOccurenceTable(short int accelerationBits, int wordLength);
+
+void allocateKmerOccurences(IDnum kmerCount, KmerOccurenceTable * table);
+
+void recordKmerOccurence(Kmer * kmer, IDnum nodeID, Coordinate position, KmerOccurenceTable * table);
+
+void sortKmerOccurenceTable(KmerOccurenceTable * table);
+
+KmerOccurence *findKmerInKmerOccurenceTable(Kmer * kmer,
+						     KmerOccurenceTable *
+						     table);
+
+
+void destroyKmerOccurenceTable(KmerOccurenceTable * kmerTable);
+
+// Node operations
+KmerOccurence * getNextKmerOccurence(KmerOccurence * current);
+IDnum getKmerOccurenceNodeID(KmerOccurence * occurence);
+Coordinate getKmerOccurencePosition(KmerOccurence * occurence);
+#endif 

data/ext/src/src/kseq.h

@@ -0,0 +1,223 @@
+/* The MIT License
+
+   Copyright (c) 2008 Genome Research Ltd (GRL).
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/* Contact: Heng Li <lh3@sanger.ac.uk> */
+
+/* Last Modified: 12APR2009 */
+
+#ifndef AC_KSEQ_H
+#define AC_KSEQ_H
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define KS_SEP_SPACE 0 // isspace(): \t, \n, \v, \f, \r
+#define KS_SEP_TAB   1 // isspace() && !' '
+#define KS_SEP_MAX   1
+
+#define __KS_TYPE(type_t)						\
+	typedef struct __kstream_t {				\
+		char *buf;								\
+		int begin, end, is_eof;					\
+		type_t f;								\
+	} kstream_t;
+
+#define ks_eof(ks) ((ks)->is_eof && (ks)->begin >= (ks)->end)
+#define ks_rewind(ks) ((ks)->is_eof = (ks)->begin = (ks)->end = 0)
+
+#define __KS_BASIC(type_t, __bufsize)								\
+	static inline kstream_t *ks_init(type_t f)						\
+	{																\
+		kstream_t *ks = (kstream_t*)calloc(1, sizeof(kstream_t));	\
+		ks->f = f;													\
+		ks->buf = (char*)malloc(__bufsize);							\
+		return ks;													\
+	}																\
+	static inline void ks_destroy(kstream_t *ks)					\
+	{																\
+		if (ks) {													\
+			free(ks->buf);											\
+			free(ks);												\
+		}															\
+	}
+
+#define __KS_GETC(__read, __bufsize)						\
+	static inline int ks_getc(kstream_t *ks)				\
+	{														\
+		if (ks->is_eof && ks->begin >= ks->end) return -1;	\
+		if (ks->begin >= ks->end) {							\
+			ks->begin = 0;									\
+			ks->end = __read(ks->f, ks->buf, __bufsize);	\
+			if (ks->end < __bufsize) ks->is_eof = 1;		\
+			if (ks->end == 0) return -1;					\
+		}													\
+		return (int)ks->buf[ks->begin++];					\
+	}
+
+#ifndef KSTRING_T
+#define KSTRING_T kstring_t
+typedef struct __kstring_t {
+	size_t l, m;
+	char *s;
+} kstring_t;
+#endif
+
+#ifndef kroundup32
+#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+#endif
+
+#define __KS_GETUNTIL(__read, __bufsize)								\
+	static int ks_getuntil(kstream_t *ks, int delimiter, kstring_t *str, int *dret) \
+	{																	\
+		if (dret) *dret = 0;											\
+		str->l = 0;														\
+		if (ks->begin >= ks->end && ks->is_eof) return -1;				\
+		for (;;) {														\
+			int i;														\
+			if (ks->begin >= ks->end) {									\
+				if (!ks->is_eof) {										\
+					ks->begin = 0;										\
+					ks->end = __read(ks->f, ks->buf, __bufsize);		\
+					if (ks->end < __bufsize) ks->is_eof = 1;			\
+					if (ks->end == 0) break;							\
+				} else break;											\
+			}															\
+			if (delimiter > KS_SEP_MAX) {								\
+				for (i = ks->begin; i < ks->end; ++i)					\
+					if (ks->buf[i] == delimiter) break;					\
+			} else if (delimiter == KS_SEP_SPACE) {						\
+				for (i = ks->begin; i < ks->end; ++i)					\
+					if (isspace(ks->buf[i])) break;						\
+			} else if (delimiter == KS_SEP_TAB) {						\
+				for (i = ks->begin; i < ks->end; ++i)					\
+					if (isspace(ks->buf[i]) && ks->buf[i] != ' ') break; \
+			} else i = 0; /* never come to here! */						\
+			if (str->m - str->l < i - ks->begin + 1) {					\
+				str->m = str->l + (i - ks->begin) + 1;					\
+				kroundup32(str->m);										\
+				str->s = (char*)realloc(str->s, str->m);				\
+			}															\
+			memcpy(str->s + str->l, ks->buf + ks->begin, i - ks->begin); \
+			str->l = str->l + (i - ks->begin);							\
+			ks->begin = i + 1;											\
+			if (i < ks->end) {											\
+				if (dret) *dret = ks->buf[i];							\
+				break;													\
+			}															\
+		}																\
+		if (str->l == 0) {												\
+			str->m = 1;													\
+			str->s = (char*)calloc(1, 1);								\
+		}																\
+		str->s[str->l] = '\0';											\
+		return str->l;													\
+	}
+
+#define KSTREAM_INIT(type_t, __read, __bufsize) \
+	__KS_TYPE(type_t)							\
+	__KS_BASIC(type_t, __bufsize)				\
+	__KS_GETC(__read, __bufsize)				\
+	__KS_GETUNTIL(__read, __bufsize)
+
+#define __KSEQ_BASIC(type_t)											\
+	static inline kseq_t *kseq_init(type_t fd)							\
+	{																	\
+		kseq_t *s = (kseq_t*)calloc(1, sizeof(kseq_t));					\
+		s->f = ks_init(fd);												\
+		return s;														\
+	}																	\
+	static inline void kseq_rewind(kseq_t *ks)							\
+	{																	\
+		ks->last_char = 0;												\
+		ks->f->is_eof = ks->f->begin = ks->f->end = 0;					\
+	}																	\
+	static inline void kseq_destroy(kseq_t *ks)							\
+	{																	\
+		if (!ks) return;												\
+		free(ks->name.s); free(ks->comment.s); free(ks->seq.s);	free(ks->qual.s); \
+		ks_destroy(ks->f);												\
+		free(ks);														\
+	}
+
+/* Return value:
+   >=0  length of the sequence (normal)
+   -1   end-of-file
+   -2   truncated quality string
+ */
+#define __KSEQ_READ														\
+	static int kseq_read(kseq_t *seq)									\
+	{																	\
+		int c;															\
+		kstream_t *ks = seq->f;											\
+		if (seq->last_char == 0) { /* then jump to the next header line */ \
+			while ((c = ks_getc(ks)) != -1 && c != '>' && c != '@');	\
+			if (c == -1) return -1; /* end of file */					\
+			seq->last_char = c;											\
+		} /* the first header char has been read */						\
+		seq->comment.l = seq->seq.l = seq->qual.l = 0;					\
+		if (ks_getuntil(ks, 0, &seq->name, &c) < 0) return -1;			\
+		if (c != '\n') ks_getuntil(ks, '\n', &seq->comment, 0);			\
+		while ((c = ks_getc(ks)) != -1 && c != '>' && c != '+' && c != '@') { \
+			if (isgraph(c)) { /* printable non-space character */		\
+				if (seq->seq.l + 1 >= seq->seq.m) { /* double the memory */ \
+					seq->seq.m = seq->seq.l + 2;						\
+					kroundup32(seq->seq.m); /* rounded to next closest 2^k */ \
+					seq->seq.s = (char*)realloc(seq->seq.s, seq->seq.m); \
+				}														\
+				seq->seq.s[seq->seq.l++] = (char)c;						\
+			}															\
+		}																\
+		if (c == '>' || c == '@') seq->last_char = c; /* the first header char has been read */	\
+		seq->seq.s[seq->seq.l] = 0;	/* null terminated string */		\
+		if (c != '+') return seq->seq.l; /* FASTA */					\
+		if (seq->qual.m < seq->seq.m) {	/* allocate enough memory */	\
+			seq->qual.m = seq->seq.m;									\
+			seq->qual.s = (char*)realloc(seq->qual.s, seq->qual.m);		\
+		}																\
+		while ((c = ks_getc(ks)) != -1 && c != '\n'); /* skip the rest of '+' line */ \
+		if (c == -1) return -2; /* we should not stop here */			\
+		while ((c = ks_getc(ks)) != -1 && seq->qual.l < seq->seq.l)		\
+			if (c >= 33 && c <= 127) seq->qual.s[seq->qual.l++] = (unsigned char)c;	\
+		seq->qual.s[seq->qual.l] = 0; /* null terminated string */		\
+		seq->last_char = 0;	/* we have not come to the next header line */ \
+		if (seq->seq.l != seq->qual.l) return -2; /* qual string is shorter than seq string */ \
+		return seq->seq.l;												\
+	}
+
+#define __KSEQ_TYPE(type_t)						\
+	typedef struct {							\
+		kstring_t name, comment, seq, qual;		\
+		int last_char;							\
+		kstream_t *f;							\
+	} kseq_t;
+
+#define KSEQ_INIT(type_t, __read)				\
+	KSTREAM_INIT(type_t, __read, 4096)			\
+	__KSEQ_TYPE(type_t)							\
+	__KSEQ_BASIC(type_t)						\
+	__KSEQ_READ
+
+#endif