finishm 0.0.1

data/spec/paired_end_neighbours_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "PairedNeighbours" do
+  it 'should get a paired neighbour node' do
+    f = GraphTesting.finishm_graph([[1,2],[3,4]])
+    GraphTesting.add_reads_to_nodes(f, [[1,1],[2,1],[3,2]])
+    GraphTesting.make_reads_paired(f)
+    finder = Bio::FinishM::PairedEndNeighbourFinder.new(f, 100)
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[2], :start_is_first)
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [3]
+    neighs.collect{|n| n.distance}.should == [80]
+    neighs[0].num_adjoining_reads.should == 1
+    p neighs[0]
+    p neighs[0].node
+    neighs[0].node.kind_of?(Bio::Velvet::Graph::Node).should == true
+  end
+
+  it 'should get a direct neighbour node' do
+    f = GraphTesting.finishm_graph([[1,2],[3,4]])
+    GraphTesting.add_reads_to_nodes(f, [[1,1],[2,1],[3,2]])
+    #GraphTesting.make_reads_paired(f)
+    finder = Bio::FinishM::PairedEndNeighbourFinder.new(f, 100)
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[2], :start_is_first)
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == []
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[1], :start_is_first)
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [2]
+    p neighs[0]
+    p neighs[0].node
+    neighs[0].node.kind_of?(Bio::Velvet::Graph::Node).should == true
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[2], :end_is_first)
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [1]
+  end
+
+  it 'should get both direct and paired neighbours together' do
+    f = GraphTesting.finishm_graph([[1,2],[3,4]])
+    GraphTesting.add_reads_to_nodes(f, [[1,1],[2,1],[3,2]])
+    GraphTesting.make_reads_paired(f)
+    finder = Bio::FinishM::PairedEndNeighbourFinder.new(f, 100)
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[1], :start_is_first)
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [2,3]
+    neighs.collect{|n| n.distance}.should == [0,80]
+    neighs[1].num_adjoining_reads.should == 1
+  end
+
+  it 'should choose the best direction on a paired neighbour node' do
+    f = GraphTesting.finishm_graph([[1,2],[3,4]])
+    GraphTesting.add_reads_to_nodes(f, [[1, 1],[2, 1,3,5],[3, 2,4,6]])
+    GraphTesting.make_reads_paired(f)
+
+    f.graph.nodes[3].short_reads.find{|r| r.read_id == 6}.offset_from_start_of_node = 5
+    finder = Bio::FinishM::PairedEndNeighbourFinder.new(f, 100)
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[2], :start_is_first)
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [3]
+    neigh = neighs[0]
+    neigh.distance.should == 81.66666666666667
+    neigh.num_adjoining_reads.should == 3
+
+    # confuse it so that read 6 is now facing a different direction
+    f.graph.nodes[3].short_reads.find{|r| r.read_id == 6}.direction = false #previously true
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [3]
+    neigh = neighs[0]
+    neigh.distance.should == 80
+    neigh.num_adjoining_reads.should == 2
+  end
+
+  it 'should work with min number of num_adjoining_reads' do
+    f = GraphTesting.finishm_graph([[1,2],[3,4]])
+    GraphTesting.add_reads_to_nodes(f, [[1, 1],[2, 1,3,5],[3, 2,4,6]])
+    GraphTesting.make_reads_paired(f)
+    finder = Bio::FinishM::PairedEndNeighbourFinder.new(f, 100)
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[2], :start_is_first)
+
+    finder.min_adjoining_reads = 0
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [3]
+
+    finder.min_adjoining_reads = 4
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == []
+  end
+
+  it 'should not accept when min_adjoining_reads is violated after orientation checking' do
+    f = GraphTesting.finishm_graph([[1,2],[3,4]])
+    GraphTesting.add_reads_to_nodes(f, [[1, 1],[2, 1,3,5],[3, 2,4,6]])
+    GraphTesting.make_reads_paired(f)
+    finder = Bio::FinishM::PairedEndNeighbourFinder.new(f, 100)
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[2], :start_is_first)
+
+    finder.min_adjoining_reads = 3
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [3]
+
+    f.graph.nodes[3].short_reads.get_read_by_id(4).direction = false
+    finder.min_adjoining_reads = 3
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == []
+  end
+
+  it 'should avoid high coverage nodes' do
+    f = GraphTesting.finishm_graph([[1,2],[3,4]])
+    GraphTesting.add_reads_to_nodes(f, [[1, 1],[2, 1,3,5],[3, 2,4,6]])
+    GraphTesting.make_reads_paired(f)
+    finder = Bio::FinishM::PairedEndNeighbourFinder.new(f, 100)
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[2], :start_is_first)
+
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [3]
+
+    f.graph.nodes[3].coverages = [99*10,99*10]
+
+    finder.max_adjoining_node_coverage = 98
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == []
+
+    finder.max_adjoining_node_coverage = 99
+    neighs = finder.neighbours(onode)
+    neighs.collect{|n| n.node.node_id}.should == [3]
+  end
+end

data/spec/paths_between_nodes_spec.rb

@@ -0,0 +1,349 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'bio'
+class Util
+  def self.revcom(seq)
+    Bio::Sequence::NA.new(seq).reverse_complement.to_s.upcase
+  end
+end
+
+class Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder
+  # monkey patch this so old tests work. New tests should use emit_ss
+  def find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, leash_length, start_fwd)
+    initial = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new
+    initial.node = initial_node
+    if start_fwd
+      initial.first_side = Bio::Velvet::Graph::OrientedNodeTrail::START_IS_FIRST
+    else
+      initial.first_side = Bio::Velvet::Graph::OrientedNodeTrail::END_IS_FIRST
+    end
+    initial_path = Bio::Velvet::Graph::OrientedNodeTrail.new
+    initial_path.add_oriented_node initial
+    terminal = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new
+    terminal.node = terminal_node
+    terminal.first_side = Bio::Velvet::Graph::OrientedNodeTrail::START_IS_FIRST
+
+    find_all_connections_between_two_nodes(graph, initial_path, terminal, leash_length)
+  end
+end
+
+Bio::Log::CLI.logger('stderr'); Bio::Log::CLI.trace('debug'); log = Bio::Log::LoggerPlus.new('finishm'); Bio::Log::CLI.configure('finishm')
+
+describe "PathsBetweenNodes" do
+
+  it 'should calculate a very straightforward trail' do
+    graph, initial_path, terminal_node = GraphTesting.emit_ss([
+      [1,2],
+      [2,3],
+    ], 1, 3)
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes(graph, initial_path, terminal_node, nil)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3],
+    ]
+  end
+
+  it 'should calculate a trail with just one bubble' do
+    graph, initial_path, terminal_node = GraphTesting.emit_ss([
+      [1,2],
+      [1,3],
+      [2,4],
+      [3,4],
+      [4,5],
+    ], 1, 5)
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes(graph, initial_path, terminal_node, nil)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,4,5],
+      [1,3,4,5],
+    ]
+  end
+
+  it 'should deal with cycles' do
+    graph, initial_path, terminal_node = GraphTesting.emit_ss([
+      [1,2],
+      [2,3],
+      [3,2],
+      [3,4],
+    ], 1, 4)
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes(graph, initial_path, terminal_node, nil)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4],
+    ]
+  end
+
+  it 'should find paths not both ending at terminal node' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [3,4],
+      [1,5],
+      [5,3]
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[4]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, nil, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4],
+      [1,5,3,4],
+    ]
+  end
+
+  it 'should find through consecutive loops ending at terminal' do
+    # 1 2/3 4 5/6 7
+    graph = GraphTesting.emit([
+      [1,2],
+      [1,3],
+      [2,4],
+      [3,4],
+      [4,5],
+      [4,6],
+      [5,7],
+      [6,7],
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[7]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, nil, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,4,5,7],
+      [1,2,4,6,7],
+      [1,3,4,5,7],
+      [1,3,4,6,7],
+    ]
+  end
+
+    it 'should find through consecutive loops not ending at terminal' do
+    # 1 2/3 4 5/6 7 8
+    graph = GraphTesting.emit([
+      [1,2],
+      [1,3],
+      [2,4],
+      [3,4],
+      [4,5],
+      [4,6],
+      [5,7],
+      [6,7],
+      [7,8]
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[8]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, nil, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,4,5,7,8],
+      [1,2,4,6,7,8],
+      [1,3,4,5,7,8],
+      [1,3,4,6,7,8],
+    ]
+  end
+
+  it 'should find loop off loop 1' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [2,4],
+      [3,8],
+      [4,5],
+      [4,6],
+      [5,7],
+      [6,7],
+      [7,8],
+      [8,9],
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[9]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, nil, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,8,9],
+      [1,2,4,5,7,8,9],
+      [1,2,4,6,7,8,9],
+    ].sort
+  end
+
+  it 'should find loop off loop with three way' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [1,3],
+      [1,4],
+      [2,5],
+      [3,5],
+      [4,8],
+      [5,6],
+      [5,7],
+      [6,9],
+      [7,9],
+      [8,9],
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[9]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, nil, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,5,6,9],
+      [1,2,5,7,9],
+      [1,3,5,6,9],
+      [1,3,5,7,9],
+      [1,4,8,9],
+    ].sort
+  end
+
+  it 'should not fail when there is one path beyond the leash (1st), and another not (2nd)' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [1,3],
+      [3,4],
+    ])
+    graph.hash_length = 87
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[4]
+    graph.nodes[1].ends_of_kmers_of_node = 'A'*10
+    graph.nodes[2].ends_of_kmers_of_node = 'A'*100
+    graph.nodes[3].ends_of_kmers_of_node = 'A'*10
+    graph.nodes[4].ends_of_kmers_of_node = 'A'*10
+    (1..4).each do |node_id|
+      graph.nodes[node_id].ends_of_kmers_of_twin_node = graph.nodes[node_id].ends_of_kmers_of_node
+    end
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, 200, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4],
+      [1,3,4],
+    ].sort
+
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, 100, true)
+    (1..4).each do |node_id|
+      graph.nodes[node_id].ends_of_kmers_of_twin_node = graph.nodes[node_id].ends_of_kmers_of_node
+    end
+    GraphTesting.sorted_paths(paths).should == [
+      [1,3,4],
+    ].sort
+
+  end
+
+
+  it 'probably fails with the nasty leash bug, which is hard to fix' do
+    graph = GraphTesting.emit([
+      [1,3],
+      [1,2],
+      [2,3],
+      [3,4],
+      [4,5],
+    ])
+    graph.hash_length = 87
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[5]
+    graph.nodes[1].ends_of_kmers_of_node = 'A'*10
+    graph.nodes[2].ends_of_kmers_of_node = 'A'*70
+    graph.nodes[3].ends_of_kmers_of_node = 'A'*15
+    graph.nodes[4].ends_of_kmers_of_node = 'A'*10
+    graph.nodes[5].ends_of_kmers_of_node = 'A'*10
+    (1..4).each do |node_id|
+      graph.nodes[node_id].ends_of_kmers_of_twin_node = graph.nodes[node_id].ends_of_kmers_of_node
+    end
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, 200, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4,5],
+      [1,3,4,5],
+    ].sort
+
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, 80, true)
+    (1..4).each do |node_id|
+      graph.nodes[node_id].ends_of_kmers_of_twin_node = graph.nodes[node_id].ends_of_kmers_of_node
+    end
+    GraphTesting.sorted_paths(paths).should == [
+      [1,3,4,5],
+    ].sort
+
+  end
+
+  it 'should not fail in this special case I realised might trip up the algorithm' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [3,4],
+      [4,5],
+
+      [1,6],
+      [6,3],
+      [6,5],
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[5]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, 99999, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4,5],
+      #[1,2,3,4,6,5],
+      [1,6,3,4,5],
+      [1,6,5],
+    ].sort
+  end
+
+  it 'should not fail in another special case I realised might trip up the algorithm' do
+    #NOTE: to fix this, one must first fix the above graph problem. Argh.
+    # The problem is that a simple joining of the golden path 1,2,3,4,5 and the
+    # golden fragment 1,6,3 yields a circular path
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [3,4],
+      [4,5],
+
+      [1,6],
+      [6,3],
+      [6,5],
+
+      [4,6],
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[5]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, 99999, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4,5],
+      [1,2,3,4,6,5],
+      [1,6,3,4,5],
+      [1,6,5],
+    ].sort
+  end
+
+  it 'should give the same answer as a more straightfoward (naive?) repeated depth first search style' do
+    raise "need to do some simulation work here to write the test"
+  end
+
+  it 'should not get confused by a 1 node cycle' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,2],
+      [2,3],
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[3]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, nil, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3],
+    ].sort
+  end
+
+  it 'should not get confused by a 2 node cycle' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,4],
+      [4,2],
+      [2,3],
+    ])
+    initial_node = graph.nodes[1]
+    terminal_node = graph.nodes[3]
+    cartographer = Bio::AssemblyGraphAlgorithms::PathsBetweenNodesFinder.new
+    paths = cartographer.find_all_connections_between_two_nodes_adapter(graph, initial_node, terminal_node, nil, true)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3],
+    ].sort
+  end
+end