finishm 0.0.1

data/lib/priner.rb

@@ -0,0 +1,66 @@
+
+require 'bio-logger'
+Bio::Log::LoggerPlus.new('finishm')
+module Bio
+  module FinishM
+    module Logging
+      def log
+        Bio::Log::LoggerPlus['finishm']
+      end
+    end
+  end
+end
+
+require 'oligo_designer'
+require 'kmer_multi_abundance_file'
+require 'kmer_abundance_pattern'
+
+require 'bio-velvet'
+require 'bio-velvet_underground'
+
+require 'assembly/velvet_c_binding'
+
+require 'assembly/acyclic_connection_finder'
+require 'assembly/single_coherent_paths_between_nodes'
+require 'assembly/node_finder'
+require 'assembly/c_probe_node_finder'
+require 'assembly/velvet_graph_sequence_extractor'
+require 'assembly/hybrid_velvet_graph'
+require 'assembly/a_b_visualiser'
+require 'assembly/coverage_based_graph_filter'
+require 'assembly/oriented_node_trail'
+require 'assembly/depth_first_search'
+require 'assembly/kmer_coverage_based_path_filter'
+require 'assembly/probed_graph'
+require 'assembly/read_input'
+require 'assembly/graph_generator'
+require 'assembly/fluffer'
+require 'assembly/scaffold_breaker'
+require 'assembly/graph_explorer'
+require 'assembly/all_orfs'
+require 'assembly/contig_printer'
+require 'assembly/dijkstra'
+require 'assembly/single_coherent_wanderer'
+require 'assembly/connection_interpreter'
+require 'assembly/input_genome'
+require 'assembly/read_to_node'
+require 'assembly/paired_end_neighbour_finder'
+
+require 'assembly/single_ended_assembler'
+require 'assembly/bubbly_assembler'
+require 'assembly/bad_format_writer'
+require 'assembly/height_finder'
+
+require 'finishm/primers'
+require 'finishm/primers_check'
+require 'finishm/finisher'
+require 'finishm/gapfiller'
+require 'finishm/wander'
+require 'finishm/fluff'
+require 'finishm/explore'
+require 'finishm/assemble'
+require 'finishm/visualise'
+require 'finishm/sequence'
+require 'finishm/roundup'
+require 'finishm/path_counter'
+require 'finishm/orfs_finder'

data/spec/acyclic_connection_finder_spec.rb

@@ -0,0 +1,551 @@
+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
+
+#Bio::Log::CLI.logger('stderr'); Bio::Log::CLI.trace('debug'); log = Bio::Log::LoggerPlus.new('finishm'); Bio::Log::CLI.configure('finishm'); Bio::Log::LoggerPlus.new('bio-velvet'); Bio::Log::CLI.configure('bio-velvet')
+
+describe "AcyclicConnectionFinder" do
+
+  it 'should calculate an easy trail' do
+    graph = Bio::Velvet::Graph.parse_from_file File.join(TEST_DATA_DIR, 'velvet_test_trails','Assem','LastGraph')
+    # Make sure we are on the same page
+    graph.arcs.length.should eq(4)
+    graph.nodes.length.should eq(4)
+    nodes = graph.nodes
+
+    #viser = Bio::Assembly::ABVisualiser.new
+    #gv = viser.graphviz(graph)
+    #gv.output :svg => 'a.svg', :use => :neato
+
+
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+
+    log = nil
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    GraphTesting.sorted_paths(trails).should == [
+      [1],
+    ]
+
+    log.debug "============= starting second test" if log
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[2], true)
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    log.debug "Found trails: #{trails[0].collect{|node| node.node_id}.join(',') }" if log
+    GraphTesting.sorted_paths(trails).should == [
+      [1,2],
+    ]
+
+    log.debug "============= starting third test" if log
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[3], true)
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    GraphTesting.sorted_paths(trails).should == [
+      [1,3],
+    ]
+
+    log.debug "============= starting 4th test" if log
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[4], false)
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    GraphTesting.sorted_paths(trails).should == [
+      [1,2,4],
+      [1,3,4],
+    ].sort
+  end
+
+  it 'should calculate trails in reverse' do
+    graph = Bio::Velvet::Graph.parse_from_file File.join(TEST_DATA_DIR, 'velvet_test_trails_reverse','Assem','LastGraph')
+    # Make sure we are on the same page
+    graph.arcs.length.should eq(4)
+    graph.nodes.length.should eq(4)
+    nodes = graph.nodes
+
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+
+    log = nil
+    #Bio::Log::CLI.logger('stderr'); Bio::Log::CLI.trace('debug'); log = Bio::Log::LoggerPlus.new('finishm'); Bio::Log::CLI.configure('finishm')
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    GraphTesting.sorted_paths(trails).should == [
+      [1],
+    ]
+
+    log.debug "============= starting second test" if log
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[3], false)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[2], false)
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    log.debug "Found trails: #{trails[0].collect{|node| node.node_id}.join(',') }" if log
+    GraphTesting.sorted_paths(trails).should == [
+      [3,2],
+    ]
+
+    log.debug "============= starting third test" if log
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[3], false)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[4], false)
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    GraphTesting.sorted_paths(trails).should == [
+      [3,4],
+    ]
+
+    log.debug "============= starting 4th test" if log
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[3], false)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], false)
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    GraphTesting.sorted_paths(trails).should == [
+      [3,2,1],
+      [3,4,1],
+    ]
+  end
+
+  it 'should not go overboard searching for paths' do
+    graph = Bio::Velvet::Graph.parse_from_file File.join(TEST_DATA_DIR, 'velvet_test_trails','Assem','LastGraph')
+    # Make sure we are on the same page
+    graph.arcs.length.should eq(4)
+    graph.nodes.length.should eq(4)
+    nodes = graph.nodes
+
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+
+    log = nil
+    #Bio::Log::CLI.logger('stderr'); Bio::Log::CLI.trace('debug'); log = Bio::Log::LoggerPlus.new('finishm'); Bio::Log::CLI.configure('finishm')
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[3], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[4], false)
+
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    GraphTesting.sorted_paths(trails).should == [[3,4]]
+
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 20)
+    GraphTesting.sorted_paths(trails).should == []
+
+
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[4], false)
+
+    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999999)
+    GraphTesting.sorted_paths(trails).should == [
+      [1,2,4],
+      [1,3,4],
+    ]
+
+    # Ignoring the below test because the squid way doesn't violate the leash to get both paths,
+    # where the old method did.
+    #    trails = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 228+29+224+30+2, true)
+    #    GraphTesting.sorted_paths(trails).should == [
+    #      [1,2,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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[4], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, nil)
+    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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[7], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, nil)
+    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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[8], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, nil)
+    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' 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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[9], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, nil)
+    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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[9], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, nil)
+    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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[4], true)
+    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::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 200)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4],
+      [1,3,4],
+    ].sort
+
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 100)
+    (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,2],
+      [2,3],
+      [3,4],
+      [4,5],
+      [1,3],
+    ])
+    graph.hash_length = 87
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[5], true)
+    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::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 200)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4,5],
+      [1,3,4,5],
+    ].sort
+
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 60)
+    (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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[5], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999)
+    GraphTesting.sorted_paths(paths).should == [
+      [1,2,3,4,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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[3], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, nil)
+    paths.circular_paths_detected.should == true
+    GraphTesting.sorted_paths(paths).should == [
+    ].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 = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[3], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, nil)
+    paths.circular_paths_detected.should == true
+    GraphTesting.sorted_paths(paths).should == [
+    ].sort
+  end
+
+  it 'should calculate connections using a simple depth first search' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+    ])
+    finishm_graph = Bio::FinishM::ProbedGraph.new
+    finishm_graph.graph = graph
+    finishm_graph.probe_nodes = [graph.nodes[1],graph.nodes[2]]
+    finishm_graph.probe_node_directions = [true, false]
+
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    cartographer.depth_first_search_with_leash(finishm_graph, 10000).should == {
+      [0,1] => 10
+    }
+  end
+
+  it 'should calculate connections using a simple depth first search multiple singly connected' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [4,5]
+    ])
+    finishm_graph = Bio::FinishM::ProbedGraph.new
+    finishm_graph.graph = graph
+    finishm_graph.probe_nodes = [
+      graph.nodes[1],graph.nodes[3],
+      graph.nodes[4],graph.nodes[5],
+    ]
+    finishm_graph.probe_node_directions = [true, false, true, false]
+
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    cartographer.depth_first_search_with_leash(finishm_graph, 10000).should == {
+      [0,1] => 20,
+      [2,3] => 10,
+    }
+  end
+
+  it 'should calculate connections using a simple depth first search multiply connected' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [3,4],
+      [4,5],
+    ])
+    finishm_graph = Bio::FinishM::ProbedGraph.new
+    finishm_graph.graph = graph
+    finishm_graph.probe_nodes = [
+      graph.nodes[1],graph.nodes[3],
+      graph.nodes[4],graph.nodes[5],
+    ]
+    finishm_graph.probe_node_directions = [true, false, true, false]
+
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    cartographer.depth_first_search_with_leash(finishm_graph, 10000).should == {
+      [0,1] => 20,
+      [0,3] => 40,
+      [2,3] => 10,
+    }
+  end
+
+  it 'should calculate connections using a simple depth first search respect leash' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [3,4],
+      [4,5],
+    ])
+    finishm_graph = Bio::FinishM::ProbedGraph.new
+    finishm_graph.graph = graph
+    finishm_graph.probe_nodes = [
+      graph.nodes[1],graph.nodes[3],
+      graph.nodes[4],graph.nodes[5],
+    ]
+    finishm_graph.probe_node_directions = [true, false, true, false]
+
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    cartographer.depth_first_search_with_leash(finishm_graph, 20).should == {
+      [0,1] => 20,
+      #[0,3] => 40,
+      [2,3] => 10,
+    }
+  end
+
+  it 'should find a path when the initial is the terminal and directions match' do
+    graph = GraphTesting.emit([
+      [1,2],
+    ])
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999)
+    GraphTesting.sorted_paths(paths).should == [
+      [1],
+      ].sort
+  end
+
+  it 'should not find a path when the initial is the terminal but the directions do not match' do
+    graph = GraphTesting.emit([
+      [1,2],
+    ])
+    initial_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+    terminal_node = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], false)
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_node, terminal_node, 99999)
+    GraphTesting.sorted_paths(paths).should == [
+      ].sort
+  end
+
+  it 'should work with a recoherence kmer' do # There is more in-depth testing of this in another spec file
+    graph, initial_path, terminal_onode = GraphTesting.emit_ss([
+      [1,2],
+      [2,3],
+      [1,5],
+      [5,3],
+
+      [3,4],
+    ], 1, 4)
+    GraphTesting.add_noded_reads(graph,[
+      [1,2,3,4],
+      [1,5],
+      ])
+    cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    paths = cartographer.find_trails_between_nodes(graph, initial_path.trail[0], terminal_onode, 99999, :recoherence_kmer => 15)
+    paths.circular_paths_detected.should == false
+    GraphTesting.sorted_paths(paths.trails).should == [
+      [1,2,3,4],
+    ]
+  end
+
+  it 'should calibrate when both start and end nodes are the same' do
+    fail
+  end
+
+  it 'should calibrate when start and end nodes are different' do
+    probe_sequences = [
+      'GCATACGTATGCATGTTGCGCTGTTTGACCCGAAATGGTGCCCGGAGCAAGGCTTAGCATCCAATGCAGATAGCCCAGCTCTACTCA',
+      'ACTGGAGTCGGCGCGATCGCGGCGGTTAGTAGGCTCTTGAGTACCCATGCTTCCTCAGCTCTATGATGAACCCAGTGCCTGGGCGCCCATT',
+      ]
+    reads = Bio::FinishM::ReadInput.new
+    reads.parse_options({
+      :fasta_gz_singles => [
+        File.join(TEST_DATA_DIR,'acyclic_connection_finder','1','random1.sammy.fa.gz'),
+        File.join(TEST_DATA_DIR,'acyclic_connection_finder','1','random2.sammy.fa.gz'),
+        ],
+      })
+    graph = Bio::FinishM::GraphGenerator.new.generate_graph(probe_sequences, reads,
+      {:velvet_kmer_size => 51,
+        :assembly_coverage_cutoff => 0.5,
+        }
+      )
+    # Number	Name	Length
+    # 1	probe_fwd	87
+    # 2	probe_rev_revcom	91
+    distancer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+    distancer.calibrate_distance_accounting_for_probes(
+      graph, 0, 1, 24
+      ).should == 0
+
+    fail "do more testing here"
+  end
+end