finishm 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/readToNode.c

@@ -0,0 +1,218 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "globals.h"
+#include "utility.h"
+#include "readToNode.h"
+#include "graphStructures.h"
+#include "graph.h"
+
+// comparison function for qsort. Sort ascending, first by read ID then by node ID
+static int read_id_node_id_compare_function(const void *p1, const void *p2){
+  ReadIdNodeId* rn1 = (ReadIdNodeId*) p1;
+  ReadIdNodeId* rn2 = (ReadIdNodeId*) p2;
+  if (rn1->read_id < rn2->read_id)
+    return -1;
+  else if (rn1->read_id > rn2->read_id)
+    return 1;
+    else return (rn1->node_id - rn2->node_id);
+}
+
+/** Create a new ReadIdToNodeIdHash structure with all the given
+information in the graph passed here.
+*/
+ReadIdToNodeIdLookupTable* createReadToNode(Graph* graph){
+  // malloc array of read_id_node_id structs that is 1/10 the size of the number of nodes,
+  // or 100, whichever is larger (to account for if the number of nodes < 10
+  IDnum reads_and_nodes_length = graph->nodeCount / 10;
+  if (reads_and_nodes_length < 100)
+    reads_and_nodes_length = 100;
+  ReadIdNodeId* reads_and_nodes = mallocOrExit(reads_and_nodes_length, ReadIdNodeId);
+
+  IDnum reads_and_nodes_count = 0;
+  IDnum reads_and_nodes_step_size = reads_and_nodes_length;
+
+  // write reads_and_nodes array unsorted
+  // For each node in order
+  IDnum i, j, k;
+  // to prevent code duplication, create an array of 2 node pointers
+  Node** fwd_and_rev_nodes = mallocOrExit(2, Node*);
+  Node* current_node;
+  ShortReadMarker current_read;
+  IDnum num_short_reads_attached;
+  ShortReadMarker* current_node_reads;
+  for (i=0; i<graph->nodeCount; i++){
+    current_node = getNodeInGraph(graph, i+1);
+    if (getNodeID(current_node) < 0)
+      continue; //ignore reverse nodes as these are already taken care of
+
+    fwd_and_rev_nodes[0] = current_node;
+    fwd_and_rev_nodes[1] = getTwinNode(current_node);
+    for (j=0; j<2; j++){
+      current_node = fwd_and_rev_nodes[j];
+      num_short_reads_attached = getNodeReadCount(current_node, graph);
+      current_node_reads = getNodeReads(current_node, graph);
+
+      for (k=0; k<num_short_reads_attached; k++){
+        // For each fwd facing short read attached to the node
+        // if we are beyond capacity, realloc some more
+        if (reads_and_nodes_count >= reads_and_nodes_length){
+          reads_and_nodes_length += reads_and_nodes_step_size;
+          //printf("Re-allocing to size %i\n", reads_and_nodes_length);
+          reads_and_nodes = reallocOrExit(reads_and_nodes, reads_and_nodes_length, ReadIdNodeId);
+        }
+
+        // add the current read
+        current_read = current_node_reads[k];
+        //printf("Accessing index %i\n", reads_and_nodes_count);
+        ReadIdNodeId* rid_nid = &(reads_and_nodes[reads_and_nodes_count]);
+        rid_nid->read_id = current_read.readID;
+        rid_nid->node_id = current_node->ID;
+
+        //increment the counter
+        reads_and_nodes_count += 1;
+      }
+    }
+  }
+  free(fwd_and_rev_nodes);
+
+  //realloc down to the final size
+  reads_and_nodes_length = reads_and_nodes_count;
+  reads_and_nodes = reallocOrExit(reads_and_nodes, reads_and_nodes_length, ReadIdNodeId);
+
+  //quicksort the struct array, sorting only by read ID
+  qsort(reads_and_nodes, reads_and_nodes_length, sizeof(ReadIdNodeId), read_id_node_id_compare_function);
+
+  // malloc an index array of read id to reads_and_nodes offset the same length as the total number of reads
+  // the largest read ID recorded is the read ID of the largest (now sorted) reads_and_nodes
+  IDnum num_reads = reads_and_nodes[reads_and_nodes_length-1].read_id;
+  IDnum* index_array = callocOrExit(num_reads, IDnum);
+
+  // with sorted read_id_node_id array, write out the index array
+  IDnum last_read_id = 0;
+  for (i=0; i<reads_and_nodes_length; i++){
+    //if the last node id is different to the current node ID, write the new one to the index
+    if (reads_and_nodes[i].read_id != last_read_id ){
+      index_array[reads_and_nodes[i].read_id-1] = i;
+      last_read_id = reads_and_nodes[i].read_id;
+    }
+  }
+
+  ReadIdToNodeIdLookupTable* lookupTable = mallocOrExit(1, ReadIdToNodeIdLookupTable);
+  lookupTable->num_contents = reads_and_nodes_length;
+  lookupTable->num_reads = num_reads;
+  lookupTable->contents = reads_and_nodes;
+  lookupTable->index = index_array;
+  return lookupTable;
+}
+
+
+
+//write structure to file
+void writeReadIdToNodeIdLookupTable(char* fileName, ReadIdToNodeIdLookupTable* lookupTable){
+  FILE* fp = fopen(fileName, "wb");
+  if (fp == NULL)
+    velvetLog("Unable to open %s for reading\n", fileName);
+
+  //write overall struct info
+  ReadIdToNodeIdLookupTableFileHeader header;
+  header.num_contents = lookupTable->num_contents;
+  header.num_reads = lookupTable->num_reads;
+  fwrite(&header, sizeof(ReadIdToNodeIdLookupTableFileHeader), 1, fp);
+
+  //write index array
+  fwrite(lookupTable->index, sizeof(IDnum), lookupTable->num_reads, fp);
+
+  //write contents array
+  fwrite(lookupTable->contents, sizeof(ReadIdNodeId), lookupTable->num_contents, fp);
+
+  //close up shop
+  fclose(fp);
+}
+
+//read structure from file
+ReadIdToNodeIdLookupTable* readReadIdToNodeIdLookupTable(char* fileName){
+  //open file
+  FILE* fp = fopen(fileName, "rb");
+  if (fp == NULL)
+    velvetLog("Unable to open %s for reading\n", fileName);
+
+  ReadIdToNodeIdLookupTable* lookupTable = mallocOrExit(1, ReadIdToNodeIdLookupTable);
+
+  // read header
+  ReadIdToNodeIdLookupTableFileHeader header;
+  if (fread(&header, sizeof(header), 1, fp) != 1){
+		velvetLog("Unable to read file %s\n", fileName);
+		fclose(fp);
+		return NULL;
+  }
+  lookupTable->num_contents = header.num_contents;
+  lookupTable->num_reads = header.num_reads;
+
+  //read index array
+  lookupTable->index = callocOrExit((lookupTable->num_reads), IDnum);
+  if (fread(lookupTable->index, sizeof(IDnum), lookupTable->num_reads, fp) != lookupTable->num_reads){
+		velvetLog("Unknown format (at index stage) for file %s\n", fileName);
+		fclose(fp);
+		return NULL;
+  }
+
+  //read contents array
+  lookupTable->contents = mallocOrExit(lookupTable->num_contents, ReadIdNodeId);
+  if (fread(lookupTable->contents, sizeof(ReadIdNodeId), lookupTable->num_contents, fp) != lookupTable->num_contents){
+		velvetLog("Unknown format (at contents stage) for file %s\n", fileName);
+		fclose(fp);
+		return NULL;
+  }
+
+  //close up shop
+  fclose(fp);
+
+  return lookupTable;
+}
+
+/* The main 'getter' function here. Return a struct representing an array start pointer and number of nodes
+(array entries) that the read is attached to. No memory is malloc'd during this procedure so no free-ing is
+required.
+*/
+ReadIdToNodeIdIndexation getReadIdToNodeIdIndexation(ReadIdToNodeIdLookupTable* lookupTable, IDnum readID){
+  ReadIdToNodeIdIndexation toReturn;
+
+  if (readID > lookupTable->num_reads){
+    toReturn.num_nodes = 0;
+    return toReturn;
+  }
+
+  toReturn.read_ids_node_ids = lookupTable->contents + lookupTable->index[readID-1]; //minus one as the array is 0-indexed
+
+  // work out the number of nodes by using the next read's offset, or the total size of the array
+  // however, if the next read has no nodes associated, then need to get the one after, and so on.
+  IDnum nextReadID = readID;
+  while (nextReadID < lookupTable->num_reads){
+    if (lookupTable->index[nextReadID] != 0)
+      break;
+    else
+      nextReadID += 1;
+  }
+  //printf("Using next read ID %i for input read %i\n", nextReadID+1, readID);
+  if (readID != 1 && lookupTable->index[readID-1] == 0 && lookupTable->index[nextReadID] != 0){
+    // this read is not associated with any node
+    toReturn.num_nodes = 0;
+  } else if (nextReadID >= lookupTable->num_reads){
+    //last read associated with any node case
+    toReturn.num_nodes = lookupTable->num_contents - lookupTable->index[readID-1];
+  } else {
+    //regular case
+    toReturn.num_nodes = lookupTable->index[nextReadID] - lookupTable->index[readID-1];
+  }
+
+  return toReturn;
+}
+
+
+void destroyReadIdToNodeIdLookupTable(ReadIdToNodeIdLookupTable* lookupTable){
+  free(lookupTable->index);
+  free(lookupTable->contents);
+  free(lookupTable);
+}

data/ext/src/src/readToNode.h

@@ -0,0 +1,35 @@
+#ifndef _READ_TO_NODE_H_
+#define _READ_TO_NODE_H_
+
+typedef struct {
+  IDnum read_id;
+  IDnum node_id;
+} ReadIdNodeId; //this is a doubly used structure, once for creation of the data structure, and also in the result of the indexation. This is a little bad, but eh.
+
+typedef struct {
+  IDnum num_contents;
+  IDnum num_reads;
+  IDnum* index;
+  ReadIdNodeId* contents;
+} ReadIdToNodeIdLookupTable;
+
+//TODO: add 'writing is complete' flag like other velvet functions
+typedef struct {
+  IDnum num_contents;
+  IDnum num_reads;
+} ReadIdToNodeIdLookupTableFileHeader;
+
+typedef struct {
+  IDnum num_nodes;
+  ReadIdNodeId* read_ids_node_ids;
+} ReadIdToNodeIdIndexation;
+
+ReadIdToNodeIdLookupTable* createReadToNode(Graph* graph);
+void destroyReadIdToNodeIdLookupTable(ReadIdToNodeIdLookupTable* lookupTable);
+
+ReadIdToNodeIdIndexation getReadIdToNodeIdIndexation(ReadIdToNodeIdLookupTable* lookupTable, IDnum readID);
+
+void writeReadIdToNodeIdLookupTable(char* fileName, ReadIdToNodeIdLookupTable* lookupTable);
+ReadIdToNodeIdLookupTable* readReadIdToNodeIdLookupTable(char* fileName);
+
+#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