bio-velvet_underground 0.0.1 → 0.1.0

data/lib/bio-velvet_underground/constants.rb

@@ -0,0 +1,33 @@
+# This constants file is included during the installation make process, and
+# so cannot rely on the rest of the bio-velvet_underground code
+module Bio
+  module Velvet
+    class Underground
+      DEFAULT_MAXKMERLENGTH=31
+
+      # Different versions of velvet are compiled on installation of bio-velvet_underground.
+      # These are the different MAXKMERLENGTH parameters that are given to the velvet Makefile.
+      # See the velvet manual for more information on this.
+      def self.max_kmers
+        [31,63,127,255]
+      end
+
+      # Where is the library given the max_kmer_length
+      def self.library_location_of(max_kmer_length=nil)
+        if !Bio::Velvet::Underground.max_kmers.include?(max_kmer_length) and
+          !max_kmer_length.nil?
+          raise "bad max kmer length #{max_kmer_length}"
+        end
+
+        extras = []
+        if !max_kmer_length.nil? and max_kmer_length != DEFAULT_MAXKMERLENGTH
+          extras.push "-maxkmer#{max_kmer_length}"
+        end
+        return File.join(
+          File.dirname(__FILE__),
+          'external',
+          "libvelvet#{extras.join('') }.so.1.0")
+      end
+    end
+  end
+end

data/lib/bio-velvet_underground/graph.rb

@@ -0,0 +1,262 @@
+require 'csv'
+
+class Bio::Velvet::Underground
+
+  class Graph
+    attr_accessor :internal_graph_struct
+
+    # Use parse_from_file, not #new
+    def initialize(graph_struct)
+      @internal_graph_struct = graph_struct
+    end
+
+    # Read in a graph from a file
+    def self.parse_from_file(path)
+      # First read the first line of the file to determine which underground velvet library to load
+      hash_length = nil
+      CSV.foreach(path, :col_sep => "\t") do |row|
+        raise "Badly formatted graph file" if row.length < 3
+        hash_length = row[2].to_i
+        if hash_length < 1 or hash_length > Bio::Velvet::Underground.max_kmers.max
+          raise "unable to load velvet shared library for kmer length `#{hash_length}'"
+        end
+        break
+      end
+      raise "No lines in graph file `#{path}', is it really a velvet LastGraph-type file?" if hash_length.nil?
+
+      # setup FFI in the underground base class with the correct kmer length
+      Bio::Velvet::Underground.attach_shared_library(:kmer => hash_length)
+
+      # Using the loaded velvet library, do the actual import of the graph
+      pointer = Bio::Velvet::Underground.importGraph path
+      struct = Bio::Velvet::Underground::GraphStruct.new pointer
+      Graph.new struct
+    end
+
+    def nodes
+      NodeArray.new self
+    end
+
+    def node_count
+      @internal_graph_struct[:nodeCount]
+    end
+
+    def hash_length
+      @internal_graph_struct[:wordLength]
+    end
+
+
+    class NodeArray
+      include Enumerable
+
+      def initialize(graph)
+        @graph = graph
+      end
+
+      def each
+        (1..length).each do |node_id|
+          yield self[node_id]
+        end
+      end
+
+      def length
+        Bio::Velvet::Underground.nodeCount @graph.internal_graph_struct
+      end
+
+      def [](node_id)
+        return nil if node_id < 1 or node_id > @graph.internal_graph_struct[:nodeCount]
+        pointer = Bio::Velvet::Underground.getNodeInGraph @graph.internal_graph_struct, node_id
+        node_struct = Bio::Velvet::Underground::NodeStruct.new pointer
+        Node.new(@graph, node_struct)
+      end
+    end
+
+    class Node
+      attr_accessor :internal_node_struct
+
+      def initialize(graph, node_struct)
+        @graph = graph
+        @internal_node_struct = node_struct
+      end
+
+      def node_id
+        @internal_node_struct[:ID]
+      end
+
+      def length_alone
+        @internal_node_struct[:length]
+      end
+
+      def coverages
+        [
+          @internal_node_struct[:virtualCoverage1],
+          @internal_node_struct[:virtualCoverage2],
+          ]
+      end
+
+      def ends_of_kmers_of_node
+        seq = []
+        key = %w(A C G T)
+        0.upto(length_alone-1) do |i|
+          n = Bio::Velvet::Underground.getNucleotideInNode(@internal_node_struct, i)
+          seq.push key[n]
+        end
+        return seq.join
+      end
+
+      def ends_of_kmers_of_twin_node
+        twin.ends_of_kmers_of_node
+      end
+
+      def twin
+        return @twin unless @twin.nil?
+
+        twin_pointer = Bio::Velvet::Underground.getTwinNode(@internal_node_struct)
+        @twin = Bio::Velvet::Underground::Graph::Node.new(
+          @graph,
+          Bio::Velvet::Underground::NodeStruct.new(twin_pointer)
+          )
+      end
+
+      def fwd_short_reads
+        array_start_pointer = Bio::Velvet::Underground.getNodeReads @internal_node_struct, @graph.internal_graph_struct
+        num_short_reads = Bio::Velvet::Underground.getNodeReadCount @internal_node_struct, @graph.internal_graph_struct
+        short_reads = (0...num_short_reads).collect do |i|
+          # Use the fact that FFI pointers can do pointer arithmetic
+          pointer = array_start_pointer+(i*Bio::Velvet::Underground::ShortReadMarker.size)
+          NodedRead.new Bio::Velvet::Underground::ShortReadMarker.new(pointer), true
+        end
+        return short_reads
+      end
+
+      def rev_short_reads
+        twin.fwd_short_reads
+      end
+
+      def short_reads
+        reads = fwd_short_reads
+        rev_short_reads.each do |read|
+          read.direction = false
+          reads.push read
+        end
+        return reads
+      end
+
+    end
+
+    # TODO: this class is currently unimplemented.
+    class ArcArray
+      def initialize(graph_struct)
+        @internal_graph_struct = graph_struct
+      end
+
+      def get_arcs_by_node_id(node_id1, node_id2=nil)
+        raise
+      end
+    end
+
+    class NodedRead
+      attr_accessor :direction
+
+      def initialize(short_read_struct, direction)
+        @internal_short_read_struct = short_read_struct
+        @direction = direction
+      end
+
+      def read_id
+        @internal_short_read_struct[:readID]
+      end
+
+      def offset_from_start_of_node
+        @internal_short_read_struct[:position]
+      end
+
+      def start_coord
+        @internal_short_read_struct[:offset]
+      end
+    end
+  end
+
+
+  private
+  class GraphStruct < FFI::Struct
+    #class struct graph_st {
+    layout :nodes, :pointer, # Node **nodes;
+    :arcLookupTable, :pointer, # Arc **arcLookupTable;
+    :nodeReads, :pointer, # ShortReadMarker **nodeReads;
+    :nodeReadCounts, :pointer, # IDnum *nodeReadCounts;
+    :gapMarkers, :pointer, # GapMarker **gapMarkers;
+    #TODO: here default compilation settins are assumed (CATEGORIES=2) - probably not a future-proof assumption
+    :insertLengths0, :int64, # Coordinate insertLengths[CATEGORIES + 1];
+    :insertLengths1, :int64, # Coordinate insertLengths[CATEGORIES + 1];
+    :insertLengths2, :int64, # Coordinate insertLengths[CATEGORIES + 1];
+    :insertLengths_var0, :pointer, # double insertLengths_var[CATEGORIES + 1];
+    :insertLengths_var1, :pointer, # double insertLengths_var[CATEGORIES + 1];
+    :insertLengths_var2, :pointer, # double insertLengths_var[CATEGORIES + 1];
+    :sequenceCount, :int32, # IDnum sequenceCount;
+    :nodeCount, :int32, # IDnum nodeCount;
+    :wordLength, :int, # int wordLength;
+    :double_stranded, :bool # boolean double_stranded;
+  end
+
+  class NodeStruct < FFI::Struct
+    pack 1  # pack all members on a 1 byte boundary
+    #     struct node_st {
+    layout :twinNode, :pointer, # 	Node *twinNode;		// 64
+    :arc, :pointer, # 	Arc *arc;		// 64
+    :descriptor, :pointer, # 	Descriptor *descriptor;	// 64
+    :marker, :uint32, # 	PassageMarkerI marker;	// 32
+    :length, :int32, # 	IDnum length;	// 32
+    :virtualCoverage1, :int32, # IDnum virtualCoverage[CATEGORIES];	// 32 * 2
+    :virtualCoverage2, :int32,
+	  :originalVirtualCoverage1, :int32, # IDnum originalVirtualCoverage[CATEGORIES];	// 32 * 2
+	  :originalVirtualCoverage2, :int32,
+    :ID, :int32, # 	IDnum ID;		// 32
+    :arcCount, :int32, # 	IDnum arcCount;		// 32
+    :status, :int8, # 	boolean status;		// 1
+    :uniqueness, :int8 # 	boolean uniqueness;	// 1
+    #} ATTRIBUTE_PACKED;
+  end
+
+  class ArcStruct < FFI::Struct
+    pack 1  # pack all members on a 1 byte boundary
+    # struct arc_st {
+    layout :twinArc, :pointer, # 	Arc *twinArc;		// 64
+    :next, :pointer, # 	Arc *next;		// 64
+    :previous, :pointer, # 	Arc *previous;		// 64
+    :nextInLookupTable, :pointer, # 	Arc *nextInLookupTable;	// 64
+    :destination, :pointer, # 	Node *destination;	// 64
+    :multiplicity, :int32 # 	IDnum multiplicity;	// 32
+    # } ATTRIBUTE_PACKED;
+  end
+
+  class ShortReadMarker < FFI::Struct
+    pack 1  # pack all members on a 1 byte boundary
+    # struct shortReadMarker_st {
+    layout :position, :int32, # 	IDnum position;
+    :readID, :int32, # 	IDnum readID;
+    :offset, :int16 # 	ShortLength offset;
+    # } ATTRIBUTE_PACKED;
+  end
+
+  def self.attach_graph_functions
+    attach_function :importGraph, [:string], :pointer
+    attach_function :nodeCount, [:pointer], :int32
+    # Arc *getArcBetweenNodes(Node * originNode, Node * destinationNode,
+    # Graph * graph)
+    attach_function :getArcBetweenNodes, [:pointer, :pointer, :pointer], :pointer
+
+    # Nucleotide getNucleotideInNode(Node * node, Coordinate index) {
+    attach_function :getNucleotideInNode, [:pointer, :int32], :char
+    # IDnum getNodeID(Node * node)
+    # Node *getNodeInGraph(Graph * graph, IDnum nodeID)
+    attach_function :getNodeInGraph, [:pointer, :int32], :pointer
+    # Node *getTwinNode(Node * node);
+    attach_function :getTwinNode, [:pointer], :pointer
+
+    # ShortReadMarker *getNodeReads(Node * node, Graph * graph);
+    attach_function :getNodeReads, [:pointer, :pointer], :pointer
+    # IDnum getNodeReadCount(Node * node, Graph * graph);
+    attach_function :getNodeReadCount, [:pointer, :pointer], :int32
+  end
+end

data/lib/bio-velvet_underground/runner.rb

@@ -0,0 +1,59 @@
+class Bio::Velvet::Underground
+  class Runner
+    # Run velveth and velvetg, selecting the most memory efficient library for the purpose
+    #
+    # kmer size: (integer)
+    # velvet_directory: where to run velvet
+    # velveth_options_string: Array of string options to velveth as on the cmdline, excluding the directory and kmer
+    # velvetg_options_string: Array of string options to velveth as on the cmdline, excluding the directory
+    # options: other options:
+    # :velvet_directory: where to run the velvets. Required (currently).
+    def self.run(kmer, velveth_options, velvetg_options=[], options={})
+      #load library with appropriate kmer size
+      Bio::Velvet::Underground.attach_shared_library(:kmer => kmer)
+
+      velvet_directory = options[:velvet_directory]
+      raise "Need options[:velvet_directory] to run velvet" if velvet_directory.nil?
+
+      # velveth
+      # Can't just pass a regular Ruby array of strings, as explained at
+      # http://zegoggl.es/2009/05/ruby-ffi-recipes.html
+      velveth_array_of_strings = []
+      velveth_array_of_strings << FFI::MemoryPointer.from_string('velveth')
+      velveth_array_of_strings << FFI::MemoryPointer.from_string(velvet_directory)
+      velveth_array_of_strings << FFI::MemoryPointer.from_string(kmer.to_s)
+      velveth_options.each do |o|
+        velveth_array_of_strings << FFI::MemoryPointer.from_string(o)
+      end
+      velveth_array_of_strings << nil
+      argv = FFI::MemoryPointer.new(:pointer, velveth_array_of_strings.length)
+      velveth_array_of_strings.each_with_index do |p, i|
+        argv[i].put_pointer(0,  p)
+      end
+      returned = Bio::Velvet::Underground.velveth velveth_array_of_strings.length-1, argv
+      raise "Error running velveth (#{returned})" unless returned == 0
+
+      # velvetg
+      velvetg_array_of_strings = []
+      velvetg_array_of_strings << FFI::MemoryPointer.from_string('velvetg')
+      velvetg_array_of_strings << FFI::MemoryPointer.from_string(velvet_directory)
+      velvetg_options.each do |o|
+        velvetg_array_of_strings << FFI::MemoryPointer.from_string(o)
+      end
+      velvetg_array_of_strings << nil
+      argv = FFI::MemoryPointer.new(:pointer, velvetg_array_of_strings.length)
+      velvetg_array_of_strings.each_with_index do |p, i|
+        argv[i].put_pointer(0,  p)
+      end
+      returned = Bio::Velvet::Underground.velvetg velvetg_array_of_strings.length-1, argv
+      raise "Error running velvetg (#{returned})" unless returned == 0
+
+      return 0
+    end
+  end
+
+  def self.attach_runner_functions
+    attach_function :velveth, [:int32, :pointer], :int32
+    attach_function :velvetg, [:int32, :pointer], :int32
+  end
+end

data/spec/binary_sequence_store_spec.rb

@@ -24,4 +24,16 @@ describe "binary sequence store" do
       seqs[78]
       }.to raise_error
   end
+
+  it 'should be able to understand mates' do
+    path = File.join TEST_DATA_DIR, '2', 'CnyUnifiedSeq'
+    seqs = Bio::Velvet::Underground::BinarySequenceStore.new path
+    seqs.is_second_in_pair?(1).should == false
+    seqs.is_second_in_pair?(2).should == true
+    seqs.is_second_in_pair?(5).should == false
+    seqs.pair_id(1).should == 2
+    seqs.pair_id(2).should == 1
+    seqs.pair_id(5).should == 6
+    seqs.pair_id(6).should == 5
+  end
 end

data/spec/data/3/Assem/Graph2

@@ -0,0 +1,40 @@
+4	5	31	1
+NODE	1	228	1140	1140	0	0
+AATCAAACTATAAAGTTTTAGAAGATAAAGTAACAACTTATACATGGGGATTCGGAGTTAAAAAAGTAGATTCAGAAAATATTTCAATAGATCTTGCAGGCGCAGCTTTTTCTGTTAGGGATAAAAATGGTAATGTAATTGGTAAATATACGTATGATTCTACTGGAAATGTGGTTTTATTAAAAGGAAAGGGTGTAACTGATAAAAATGGACGAGTTATATTTACTG
+TTACACCCTTTCCTTTTAATAAAACCACATTTCCAGTAGAATCATACGTATATTTACCAATTACATTACCATTTTTATCCCTAACAGAAAAAGCTGCGCCTGCAAGATCTATTGAAATATTTTCTGAATCTACTTTTTTAACTCCGAATCCCCATGTATAAGTTGTTACTTTATCTTCTAAAACTTTATAGTTTGATTCTAAATCGTGATCTTTGGTAGAGATAAGTG
+NODE	2	29	58	58	0	0
+GTTTAAAAGAAGGAGATTACTTTATAAAA
+AGTAAATATAACTCGTCCATTTTTATCAG
+NODE	3	224	1120	1120	0	0
+GAAGAAAAAGCTCCTAAAGGGTATAGCCTTTTAAAAGAACCAGTAAAAGTTACTATAACAGCTCAAAAAGATGATAATGGAGAGTATACTGGTCAAGCAACTATATCTGTAACTAATGGCAATGAAGCTGGAAGTATAATAAATAATATTACTATGAATGATGGCAATGTATTATTTAATGTACAAATTAAAAACTATGCTGGTATTTCACTTCCAGGTACAGG
+TTTTTAATTTGTACATTAAATAATACATTGCCATCATTCATAGTAATATTATTTATTATACTTCCAGCTTCATTGCCATTAGTTACAGATATAGTTGCTTGACCAGTATACTCTCCATTATCATCTTTTTGAGCTGTTATAGTAACTTTTACTGGTTCTTTTAAAAGGCTATACCCTTTAGGAGCTTTTTCTTCTTTTATAAAGTAATCTCCTTCTTTTAAACC
+NODE	4	38	114	114	0	0
+CGGGGGGGGGTTTAAAAGAAGGAGATTACTTTATAAAA
+CCCCCCCGCAGTAAATATAACTCGTCCATTTTTATCAG
+ARC	1	2	2
+ARC	1	4	3
+ARC	2	3	2
+ARC	-3	-4	3
+NR	-4	1
+5	0	224
+NR	-3	2
+3	0	0
+5	0	0
+NR	-2	1
+3	0	224
+NR	-1	2
+3	0	253
+5	0	262
+NR	1	3
+1	0	0
+2	0	0
+4	0	0
+NR	2	1
+1	0	228
+NR	3	3
+1	0	257
+2	0	266
+4	0	266
+NR	4	2
+2	0	228
+4	0	228

data/spec/data/3/Assem/LastGraph

@@ -0,0 +1,40 @@
+4	5	31	1
+NODE	1	228	1140	1140	0	0
+AATCAAACTATAAAGTTTTAGAAGATAAAGTAACAACTTATACATGGGGATTCGGAGTTAAAAAAGTAGATTCAGAAAATATTTCAATAGATCTTGCAGGCGCAGCTTTTTCTGTTAGGGATAAAAATGGTAATGTAATTGGTAAATATACGTATGATTCTACTGGAAATGTGGTTTTATTAAAAGGAAAGGGTGTAACTGATAAAAATGGACGAGTTATATTTACTG
+TTACACCCTTTCCTTTTAATAAAACCACATTTCCAGTAGAATCATACGTATATTTACCAATTACATTACCATTTTTATCCCTAACAGAAAAAGCTGCGCCTGCAAGATCTATTGAAATATTTTCTGAATCTACTTTTTTAACTCCGAATCCCCATGTATAAGTTGTTACTTTATCTTCTAAAACTTTATAGTTTGATTCTAAATCGTGATCTTTGGTAGAGATAAGTG
+NODE	2	29	58	58	0	0
+GTTTAAAAGAAGGAGATTACTTTATAAAA
+AGTAAATATAACTCGTCCATTTTTATCAG
+NODE	3	224	1120	1120	0	0
+GAAGAAAAAGCTCCTAAAGGGTATAGCCTTTTAAAAGAACCAGTAAAAGTTACTATAACAGCTCAAAAAGATGATAATGGAGAGTATACTGGTCAAGCAACTATATCTGTAACTAATGGCAATGAAGCTGGAAGTATAATAAATAATATTACTATGAATGATGGCAATGTATTATTTAATGTACAAATTAAAAACTATGCTGGTATTTCACTTCCAGGTACAGG
+TTTTTAATTTGTACATTAAATAATACATTGCCATCATTCATAGTAATATTATTTATTATACTTCCAGCTTCATTGCCATTAGTTACAGATATAGTTGCTTGACCAGTATACTCTCCATTATCATCTTTTTGAGCTGTTATAGTAACTTTTACTGGTTCTTTTAAAAGGCTATACCCTTTAGGAGCTTTTTCTTCTTTTATAAAGTAATCTCCTTCTTTTAAACC
+NODE	4	38	114	114	0	0
+CGGGGGGGGGTTTAAAAGAAGGAGATTACTTTATAAAA
+CCCCCCCGCAGTAAATATAACTCGTCCATTTTTATCAG
+ARC	1	2	2
+ARC	1	4	3
+ARC	2	3	2
+ARC	-3	-4	3
+NR	-4	1
+5	0	224
+NR	-3	2
+3	0	0
+5	0	0
+NR	-2	1
+3	0	224
+NR	-1	2
+3	0	253
+5	0	262
+NR	1	3
+1	0	0
+2	0	0
+4	0	0
+NR	2	1
+1	0	228
+NR	3	3
+1	0	257
+2	0	266
+4	0	266
+NR	4	2
+2	0	228
+4	0	228