finishm 0.0.1

data/lib/assembly/single_coherent_wanderer.rb

@@ -0,0 +1,261 @@
+class Bio::AssemblyGraphAlgorithms::SingleCoherentWanderer
+  include Bio::FinishM::Logging
+
+  # Like AcyclicConnectionFinder#depth_first_search_with_leash except use
+  # single read recoherence. The algorithm used is a generalisation of Dijkstra's
+  # shortest path algorithm, where instead of keeping track of the minimum
+  # distance to each node, the algorithm keeps track of the distance to a
+  # set of nodes long enough to invoke a recoherence kmer.
+  #
+  # Options:
+  # :max_explore_nodes: maximum number of nodes to explore from each node. If max is reached, don't make any connections (default: no maximum)
+  def wander(finishm_graph, leash_length, recoherence_kmer, sequence_hash, options={})
+    to_return = {}
+
+    # Take the probes and make them all into finishing nodes
+    finishing_nodes = []
+    finishm_graph.probe_nodes.each_with_index do |probe_node, probe_node_index|
+      direction = finishm_graph.probe_node_directions[probe_node_index]
+      if direction == true
+        finishing_nodes.push [probe_node.node_id, Bio::Velvet::Graph::OrientedNodeTrail::END_IS_FIRST]
+      else
+        finishing_nodes.push [probe_node.node_id, Bio::Velvet::Graph::OrientedNodeTrail::START_IS_FIRST]
+      end
+    end
+
+    # Search from each probed node in the graph
+    # TODO: is there a better way to implement this by somehow searching with
+    # all probe nodes at once, rather than starting fresh with each probe?
+    finishm_graph.probe_nodes.each_with_index do |probe_node, probe_node_index|
+
+      # Don't explore from the last node, as no new connections are established
+      next if probe_node_index == finishm_graph.probe_nodes.length - 1
+
+      # Go all the way to the leash length,
+      # and then search to see if any of the other nodes have been come across
+      log.debug "Exploring from probe node \##{probe_node_index+1} (node #{probe_node.node_id}/#{finishm_graph.probe_node_directions[probe_node_index] })" if log.debug?
+      pqueue = DS::AnyPriorityQueue.new {|a,b| a < b}
+      initial = finishm_graph.initial_path_from_probe(probe_node_index)
+      if initial.nil?
+        log.warn "Unable to start searching from probe \##{probe_node_index+1}, because it was not found in the graph. Skipping."
+        next
+      end
+      initial_distanced = DistancedOrientedNodeSet.new
+      initial_distanced.oriented_trail = initial
+      initial_distanced.distance = 0
+
+      # The minimum distance found to get to the head nodes
+      minimum_head_nodes_distances = {}
+      # Which head node sets is each node connected to?
+      node_to_head_node_sets = {}
+      #for Logging
+      last_logged_node_count = 0
+      maxed_out = false
+
+      pqueue.enqueue initial_distanced, 0
+      # While there are more node sets in the queue
+      while distanced_head_nodes = pqueue.dequeue
+        log.debug "Dequeued #{distanced_head_nodes}" if log.debug?
+        if options[:max_explore_nodes] and node_to_head_node_sets.length > options[:max_explore_nodes]
+          log.warn "Hit maximum number of nodes (#{options[:max_explore_nodes] }) while exploring from probe \##{probe_node_index+1}"
+          maxed_out = true
+          break
+        end
+        if log.info? and node_to_head_node_sets.length % 1024 == 0 and node_to_head_node_sets.length > last_logged_node_count
+          if last_logged_node_count == 0
+            log.info "While exploring from probe \##{probe_node_index+1}.."
+          end
+          log.info "So far worked with #{node_to_head_node_sets.length} distinct nodes in the assembly graph, at min distance #{distanced_head_nodes.distance}"
+          last_logged_node_count = node_to_head_node_sets.length
+        end
+
+        settable = distanced_head_nodes.to_settable
+        if minimum_head_nodes_distances.key?(settable) and
+          distanced_head_nodes.distance >= minimum_head_nodes_distances[distanced_head_nodes.to_settable].distance
+          # This node has already been explored, and no shorter path has been found here. Go no further.
+          next
+        end
+        minimum_head_nodes_distances[settable] = distanced_head_nodes
+        last_settable = distanced_head_nodes.oriented_trail.last.to_settable
+        node_to_head_node_sets[last_settable] ||= Set.new
+        node_to_head_node_sets[last_settable] << distanced_head_nodes.to_settable
+
+        if distanced_head_nodes.distance <= leash_length
+          # Still within the leash. Push into the stack all the current node's neighbours in the graph
+          last = distanced_head_nodes.oriented_trail.last
+          neighbour_onodes = finishm_graph.graph.neighbours_of(last.node, last.first_side)
+          log.debug "Found #{neighbour_onodes.length} neighbours" if log.debug?
+          if neighbour_onodes.length > 1
+            # Fork detected. Apply recoherence, and only enqueue those that pass
+            log.debug "Multiple neighbours found"
+            neighbour_onodes.each do |neighbour|
+              candidate = distanced_head_nodes.add_oriented_node_and_copy(neighbour, recoherence_kmer)
+              log.debug "Testing recoherence in candidate #{candidate.oriented_trail.to_s}" if log.debug?
+              if candidate.last_node_recoherent?(recoherence_kmer, sequence_hash)
+                log.debug "Candidate survived recoherence: #{candidate.to_s}" if log.debug?
+                pqueue.enqueue candidate, candidate.distance
+              elsif log.debug?
+                log.debug "Candidate did not survive recoherence #{candidate.oriented_trail.to_s}"
+              end
+            end
+          else
+            # One or none neighbours found. Enqueue if there is one
+            neighbour_onodes.each do |neighbour|
+              candidate = distanced_head_nodes.add_oriented_node_and_copy(neighbour, recoherence_kmer)
+              pqueue.enqueue candidate, candidate.distance
+            end
+          end
+        else
+          # we are beyond the leash, go no further
+        end
+      end
+
+      if maxed_out
+        log.debug "Maxed out, exiting loop early" if log.debug?
+        next
+      end
+
+      # Now have a hash of minimum distances. Now need to go through those and determine
+      # which other nodes the current probe node is connected to
+      finishm_graph.probe_nodes.each_with_index do |node, i|
+        next if i < probe_node_index # only return the 'upper triangle' of the distance matrices
+
+        finish = finishing_nodes[i]
+        heads = node_to_head_node_sets[finish]
+        next if heads.nil? #no connection found
+
+        # There might be many head_sets that include the finishing node.
+        # Which one has the least distance?
+        overall_min_distanced_set = nil
+        heads.each do |head_set|
+          min_distanced_set = minimum_head_nodes_distances[head_set]
+          # If there is a new winner
+          if overall_min_distanced_set.nil? or
+            overall_min_distanced_set.distance > min_distanced_set.distance
+
+            if probes_on_single_node_ok?(finishm_graph, probe_node_index, i)
+              log.debug "Verified that probe indices #{probe_node_index}/#{i} are not failing on a 1 node basis" if log.debug?
+            else
+              #TODO: Possibly ok if contigs to be scaffolded are all on the same node. Unlikely in practice due to short tips, but still theoretically possible
+              log.debug "Failed to verify that probe indices #{probe_node_index}/#{i} are not failing on a 1 node basis" if log.debug?
+              next
+            end
+
+            overall_min_distanced_set = min_distanced_set
+          end
+        end
+        next if overall_min_distanced_set.nil? #no connection found - the only connection was a fake one
+
+        min_distance = overall_min_distanced_set.distance
+        log.debug "Found a connection between probes #{probe_node_index+1} and #{i+1}, distance: #{min_distance}" if log.debug?
+        to_return[[probe_node_index, i]] = min_distance
+      end
+    end
+    return to_return
+  end
+
+  # Check for position and orientation if start and finish nodes are
+  # on the same velvet node. Return true if OK as below or if the nodes
+  # are different
+  # -->    <--- OK
+  # <--    --> not ok (unless the node is circular)
+  # <--    <-- not ok
+  # -->    --> not ok
+  def probes_on_single_node_ok?(finishm_graph, start_node_index, end_node_index)
+    node1 = finishm_graph.probe_nodes[start_node_index]
+    node2 = finishm_graph.probe_nodes[end_node_index]
+    return true if node1.node_id != node2.node_id
+
+    node1_direction = finishm_graph.probe_node_directions[start_node_index]
+    node2_direction = finishm_graph.probe_node_directions[end_node_index]
+    node1_offset = direction_independent_offset_of_noded_read_from_start_of_node(
+      node1, finishm_graph.probe_node_reads[start_node_index])
+    node2_offset = direction_independent_offset_of_noded_read_from_start_of_node(
+      node1, finishm_graph.probe_node_reads[end_node_index])
+    log.debug "Validating for 1 node problems #{start_node_index}/#{end_node_index} #{node1_direction}/#{node2_direction} offsets #{node1_offset}/#{node2_offset}" if log.debug?
+
+    # true/false and probe1 left of probe2, immediately below, is the most intuitive.
+    # but false/true and probe1 right of probe2 is also valid
+    if node1_direction == true and node2_direction == false and
+      node1_offset < node2_offset
+      return true
+    end
+    if node1_direction == false and node2_direction == true and
+      node1_offset > node2_offset
+      return true
+    end
+
+    if node1_direction == true and node2_direction == false
+      onode = finishm_graph.velvet_oriented_node(start_node_index)
+      neighbours = finishm_graph.graph.neighbours_of(onode.node, onode.first_side).collect{|n| n.node_id}
+      return true if neighbours.include?(node1)
+    end
+
+    return false
+  end
+
+  private
+  def direction_independent_offset_of_noded_read_from_start_of_node(velvet_node, velvet_noded_read)
+    if velvet_noded_read.direction == true
+      return velvet_noded_read.offset_from_start_of_node
+    elsif velvet_noded_read.direction == false
+      return velvet_node.corresponding_contig_length - velvet_noded_read.offset_from_start_of_node
+    else
+      raise "programming error - velvet_noded_read does not have valid direction"
+    end
+  end
+
+  # An oriented node some distance from the origin of exploration
+  class DistancedOrientedNodeSet
+    attr_accessor :oriented_trail, :distance
+
+    # Using Set object, often we want two separate objects to be considered equal even if
+    # they are distinct objects
+    def to_settable
+      settable = []
+      @oriented_trail.each do |onode|
+        settable.push onode.node_id
+        settable.push onode.first_side
+      end
+      return settable
+    end
+
+    # Create a copy of this object, then add the given oriented_node
+    # to this object, and discard objects from the rear of the trail if they
+    # are now of no use for recoherence. Update the distance
+    def add_oriented_node_and_copy(oriented_node, recoherence_kmer)
+      d = DistancedOrientedNodeSet.new
+      new_trail =  @oriented_trail.trail+[oriented_node]
+
+      # Remove unneeded rear nodes that cannot contribute to the recoherence
+      # calculation going forward
+      cumulative_length = 0
+      i = new_trail.length - 1
+      while i >= 0 and cumulative_length < recoherence_kmer
+        cumulative_length += new_trail[i].node.length_alone
+        i -= 1
+      end
+      i += 1
+      d.oriented_trail = Bio::Velvet::Graph::OrientedNodeTrail.new
+      d.oriented_trail.trail = new_trail[i..-1]
+      # Update distance
+      d.distance = @distance+oriented_node.node.length_alone
+
+      return d
+    end
+
+    # Is the head nodes single recoherent? Return false if not, otherwise true
+    def last_node_recoherent?(recoherence_kmer, sequence_hash)
+      @@single_recoherencer ||= Bio::AssemblyGraphAlgorithms::SingleCoherentPathsBetweenNodesFinder.new
+      return @@single_recoherencer.validate_last_node_of_path_by_recoherence(
+        @oriented_trail,
+        recoherence_kmer,
+        sequence_hash
+        )
+    end
+
+    def to_s
+      "#{@oriented_trail.to_s}(#{@distance})"
+    end
+  end
+end

data/lib/assembly/single_ended_assembler.rb

@@ -0,0 +1,441 @@
+require 'ds'
+require 'set'
+require 'ruby-progressbar'
+
+class Bio::AssemblyGraphAlgorithms::SingleEndedAssembler
+  include Bio::FinishM::Logging
+
+  DEFAULT_MAX_TIP_LENGTH = 200
+  DEFAULT_MIN_CONTIG_SIZE = 500
+  DEFAULT_MIN_CONFIRMING_RECOHERENCE_READS = 2
+
+  attr_accessor :graph
+
+  ASSEMBLY_OPTIONS = [
+    :max_tip_length,
+    :recoherence_kmer,
+    :min_confirming_recoherence_kmer_reads,
+    :sequences,
+    :leash_length,
+    :min_contig_size,
+    :max_coverage_at_fork,
+    ]
+  attr_accessor :assembly_options
+
+  # Create a new assembler given a velvet graph and velvet Sequences object
+  #
+  # Assembly options:
+  # :max_tip_length: if a path is shorter than this in bp, then it will be clipped from the path. Default 100
+  # :recoherence_kmer: attempt to separate paths by going back to the reads with this larger kmer (requires :seqeunces)
+  # :sequences: the sequences of the actual reads, probably a Bio::Velvet::Underground::BinarySequenceStore object
+  # :leash_length: don't continue assembly from nodes farther than this distance (in bp) away
+  # :min_coverage_of_start_nodes: only start exploring from nodes with this much coverage
+  # :min_contig_size: don't bother returning contigs shorter than this (default 500bp)
+  # :progressbar_io: given an IO object e.g. $stdout, write progress information
+  def initialize(graph, assembly_options={})
+    @graph = graph
+    @assembly_options = assembly_options
+    @assembly_options[:max_tip_length] ||= DEFAULT_MAX_TIP_LENGTH
+    @assembly_options[:min_contig_size] ||= DEFAULT_MIN_CONTIG_SIZE
+    @assembly_options[:min_confirming_recoherence_kmer_reads] ||= DEFAULT_MIN_CONFIRMING_RECOHERENCE_READS
+  end
+
+  # Assemble everything in the graph into OrientedNodeTrail objects.
+  # Yields an OrientedNodeTrail if a block is
+  # given, otherwise returns an array of found paths. Options for
+  # assembly are specified in assembly_options
+  def assemble
+    paths = []
+
+    # Gather a list of nodes to try starting from
+    starting_nodes = gather_starting_nodes
+    log.info "Found #{starting_nodes.length} nodes to attempt assembly from"
+
+    seen_nodes = Set.new
+    progress = setup_progressbar starting_nodes.length
+
+    # For each starting node, start the assembly process
+    dummy_trail = Bio::Velvet::Graph::OrientedNodeTrail.new
+    starting_nodes.each do |start_node|
+      log.debug "Trying to assemble from #{start_node.node_id}" if log.debug?
+
+      # If we've already covered this node, don't try it again
+      if seen_nodes.include?([start_node.node_id, Bio::Velvet::Graph::OrientedNodeTrail::START_IS_FIRST]) or
+        seen_nodes.include?([start_node.node_id, Bio::Velvet::Graph::OrientedNodeTrail::END_IS_FIRST])
+        log.debug "Already seen this node, not inspecting further" if log.debug?
+        next
+      end
+
+      # first attempt to go forward as far as possible, then reverse the path
+      # and continue until cannot go farther
+      reversed_path_forward = find_beginning_trail_from_node(start_node, seen_nodes)
+      if reversed_path_forward.nil?
+        log.debug "Could not find forward path from this node, giving up" if log.debug?
+        next
+      end
+      # Have we already seen this path before?
+      #TODO: add in recoherence logic here
+      if seen_last_in_path?(reversed_path_forward, seen_nodes)
+        log.debug "Already seen the last node of the reversed path forward: #{reversed_path_forward.trail[-1].to_shorthand}, giving up" if log.debug?
+        next
+      end
+      # Assemble ahead again
+      log.debug "reversed_path_forward: #{reversed_path_forward.to_shorthand}" if log.debug?
+      path, just_visited_onodes = assemble_from(reversed_path_forward)
+
+      # Remove nodes that have already been seen to prevent duplication
+      log.debug "Before removing already seen nodes the second time, path was #{path.length} nodes long" if log.debug?
+      remove_seen_nodes_from_end_of_path(path, seen_nodes)
+      log.debug "After removing already seen nodes the second time, path was #{path.length} nodes long" if log.debug?
+
+      # Add the now seen nodes to the list
+      just_visited_onodes.each do |onode_settable|
+        seen_nodes << onode_settable
+      end
+
+      # Record which nodes have already been visited, so they aren't visited again
+      seen_nodes.merge just_visited_onodes
+      unless progress.nil?
+        if @assembly_options[:min_coverage_of_start_nodes]
+          # TODO: this could be better by progress += (starting_nodes_just_visited.length)
+          progress.increment
+        else
+          progress.progress += just_visited_onodes.length
+        end
+      end
+
+      if path.length_in_bp < @assembly_options[:min_contig_size]
+        log.debug "Path length (#{path.length_in_bp}) less than min_contig_size (#{@assembly_options[:min_contig_size] }), not recording it" if log.debug?
+        next
+      end
+      log.debug "Found a seemingly legitimate path #{path.to_shorthand}" if log.debug?
+      if block_given?
+        yield path
+      else
+        paths.push path
+      end
+    end
+    progress.finish unless progress.nil?
+
+    return paths
+  end
+
+  def seen_last_in_path?(path, seen_nodes)
+    seen_nodes.include?(path[-1].to_settable)
+  end
+
+  def gather_starting_nodes
+    if @assembly_options[:min_coverage_of_start_nodes] or @assembly_options[:min_length_of_start_nodes]
+      starting_nodes = []
+      graph.nodes.each do |node|
+        if (@assembly_options[:min_coverage_of_start_nodes].nil? or
+          node.coverage >= @assembly_options[:min_coverage_of_start_nodes]) and
+          (@assembly_options[:min_length_of_start_nodes].nil? or
+          node.length_alone >= @assembly_options[:min_length_of_start_nodes])
+
+          starting_nodes.push node
+        end
+      end
+      return starting_nodes
+    else
+      return graph.nodes
+    end
+  end
+
+  def setup_progressbar(num_nodes)
+    progress = nil
+    if @assembly_options[:progressbar_io]
+      progress = ProgressBar.create(
+        :title => "Assembly",
+        :format => '%a %bᗧ%i %p%% %E %t',
+        :progress_mark  => ' ',
+        :remainder_mark => '･',
+        :total => num_nodes,
+        :output => @assembly_options[:progressbar_io]
+      )
+    end
+    return progress
+  end
+
+  # Given a node, return a path that does not include any short tips, or nil if none is
+  # connected to this node.
+  # With this path, you can explore forwards. This isn't very clear commenting, but
+  # I'm just making this stuff up
+  def find_beginning_trail_from_node(node, previously_seen_nodes)
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new
+    onode.node = node
+    onode.first_side = Bio::Velvet::Graph::OrientedNodeTrail::END_IS_FIRST #go backwards first, because the path will later be reversed
+    dummy_trail = Bio::Velvet::Graph::OrientedNodeTrail.new
+    dummy_trail.trail = [onode]
+
+    find_node_from_non_short_tip = lambda do |dummy_trail|
+      # go all the way forwards
+      path, visited_nodes = assemble_from(dummy_trail)
+
+      # Remove already seen nodes from the end of the trail, because
+      # they are already included in other paths and this shows
+      # up as duplicated contig stretches and this is not correct
+      log.debug "Before removing already seen nodes the first time, path was #{path.length} nodes long" if log.debug?
+      remove_seen_nodes_from_end_of_path(path, previously_seen_nodes)
+      log.debug "After removing already seen nodes the first time, path was #{path.length} nodes long" if log.debug?
+
+      # reverse the path
+      path.reverse!
+      # peel back up we aren't in a short tip (these lost nodes might be
+      # re-added later on)
+      cannot_remove_any_more_nodes = false
+      log.debug "Before pruning back, trail is #{path.to_shorthand}" if log.debug?
+      is_tip, whatever = is_short_tip?(path[-1])
+      while is_tip
+        if path.length == 1
+          cannot_remove_any_more_nodes = true
+          break
+        end
+        path.delete_at(path.length-1)
+        log.debug "After pruning back, trail is now #{path.to_shorthand}" if log.debug?
+        is_tip, whatever = is_short_tip?(path[-1])
+      end
+
+      if cannot_remove_any_more_nodes
+        nil
+      else
+        path
+      end
+    end
+
+    log.debug "Finding nearest find_connected_node_on_a_path #{node.node_id}" if log.debug?
+    if !is_short_tip?(onode)[0]
+      log.debug "fwd direction not a short tip, going with that" if log.debug?
+      path = find_node_from_non_short_tip.call(dummy_trail)
+      if !path.nil?
+        return path
+      end
+    end
+
+    log.debug "rev direction is short tip, now testing reverse" if log.debug?
+    onode.reverse!
+    if is_short_tip?(onode)[0]
+      log.debug "short tip in both directions, there is no good neighbour" if log.debug?
+      #short tip in both directions, so not a real contig
+      return nil
+    else
+      log.debug "reverse direction not a short tip, going with that" if log.debug?
+      return find_node_from_non_short_tip.call(dummy_trail)
+    end
+  end
+
+  def remove_seen_nodes_from_end_of_path(path, seen_nodes)
+    log.debug "Removing from the end of the path #{path.to_shorthand} any nodes in set of size #{seen_nodes.length}" if log.debug?
+    while !path.trail.empty?
+      last_node_index = path.length-1
+      last_node = path[last_node_index]
+
+      if seen_nodes.include?([last_node.node_id, Bio::Velvet::Graph::OrientedNodeTrail::START_IS_FIRST]) or
+        seen_nodes.include?([last_node.node_id, Bio::Velvet::Graph::OrientedNodeTrail::END_IS_FIRST])
+        path.trail.delete_at(last_node_index)
+      else
+        # Last node is not previously seen, chop no further.
+        break
+      end
+    end
+    return path
+  end
+
+  # Assemble considering reads all reads as single ended. Options:
+  # :max_tip_length: if a path is shorter than this in bp, then it will be clipped from the path. Default 100
+  # :recoherence_kmer: attempt to separate paths by going back to the reads with this larger kmer
+  # :leash_length: don't continue assembly from nodes farther than this distance (in bp) away
+  def assemble_from(initial_path, visited_onodes=Set.new)
+    options = @assembly_options
+
+    recoherencer = Bio::AssemblyGraphAlgorithms::SingleCoherentPathsBetweenNodesFinder.new
+
+    path = initial_path.copy
+    #visited_onodes = Set.new
+    initial_path[0...-1].each do |onode| #Add all except the last node to already seen nodes list
+      visited_onodes << onode.to_settable
+    end
+
+    dummy_trail = Bio::Velvet::Graph::OrientedNodeTrail.new
+    oneighbours = nil
+    while true
+      log.debug "Now assembling from #{path[-1].to_shorthand}" if log.debug?
+      if visited_onodes.include?(path[-1].to_settable)
+        log.debug "Found circularisation in path, going no further" if log.debug?
+        break
+      else
+        visited_onodes << path[-1].to_settable
+      end
+
+      if options[:leash_length] and path.length_in_bp-@graph.hash_length > options[:leash_length]
+        log.debug "Beyond leash length, going to further with assembly" if log.debug?
+        break
+      end
+
+      oneighbours = path.neighbours_of_last_node(@graph)
+      if oneighbours.length == 0
+        log.debug "Found a dead end, last node is #{path[-1].to_shorthand}" if log.debug?
+        break
+
+      elsif oneighbours.length == 1
+        to_add = oneighbours[0]
+        log.debug "Only one way to go, so going there, to #{to_add.to_shorthand}" if log.debug?
+        path.add_oriented_node to_add
+
+      else
+        # Reached a fork (or 3 or 4-fork), which way to go?
+
+        # Remove neighbours that are short tips
+        oneighbours, visiteds = remove_tips(oneighbours, @assembly_options[:max_tip_length])
+        visiteds.each do |onode_settable|
+          visited_onodes << onode_settable
+        end
+
+        if oneighbours.length == 0
+          log.debug "Found a dead end at a fork, last node is #{path[-1].to_shorthand}" if log.debug?
+          break
+        elsif oneighbours.length == 1
+          log.debug "Clipped short tip(s) off, and then there was only one way to go" if log.debug?
+          path.add_oriented_node oneighbours[0]
+        elsif options[:recoherence_kmer].nil?
+          if log.debug?
+            neighbours_string = oneighbours.collect do |oneigh|
+              oneigh.to_shorthand
+            end.join(' or ')
+            log.debug "Came across what appears to be a legitimate fork to nodes #{neighbours_string} and no recoherence kmer given, so giving up" if log.debug?
+          end
+          break
+        else
+          unless options[:recoherence_kmer].nil?
+            log.debug "Attempting to resolve fork by recoherence" if log.debug?
+            oneighbours.select! do |oneigh|
+              dummy_trail.trail = path.trail+[oneigh]
+              recoherencer.validate_last_node_of_path_by_recoherence(
+                dummy_trail,
+                options[:recoherence_kmer],
+                options[:sequences],
+                options[:min_confirming_recoherence_kmer_reads]
+                )
+            end
+          end
+          if oneighbours.length == 0
+            log.debug "no neighbours passed recoherence, giving up" if log.debug?
+            break
+          elsif oneighbours.length == 1
+            log.debug "After recoherence there's only one way to go, going there"
+            path.add_oriented_node oneighbours[0]
+          elsif options[:max_coverage_at_fork]
+            oneighbours.select! do |oneigh|
+              oneigh.node.coverage <= options[:max_coverage_at_fork]
+            end
+            log.debug "Found #{oneighbours.length} neighbours after removing nodes over max coverage" if log.debug?
+
+            if oneighbours.length == 1
+              log.debug "After removing too much coverage neighbours there's only one way to go, going there"
+              path.add_oriented_node oneighbours[0]
+            else
+              log.debug "After removing max coverage nodes, #{oneighbours.length} neighbours found (#{oneighbours.collect{|o| o.to_shorthand}.join(",") }), giving up" if log.debug?
+              break
+            end
+
+
+          else
+            log.debug "Still forked after recoherence (to #{oneighbours.collect{|on| on.to_shorthand}.join(' & ') }), so seems to be a legitimate fork, giving up" if log.debug?
+            break
+          end
+        end
+      end
+    end
+
+    visited_onodes << path[-1].to_settable
+
+    return path, visited_onodes
+  end
+
+  # Given a list of possibilities for neighbours of a node, return the
+  # neighbour(s) that are not short tips, or the longest of the short tips
+  # if all are tips. Also return an enumerable of nodes visited from the cut off
+  # short tips
+  def remove_tips(oriented_neighbours, tip_distance)
+    return [], [] if oriented_neighbours.empty?
+
+    neighbours_and_triples = oriented_neighbours.collect do |oneigh|
+      [
+        oneigh,
+        find_tip_distance(oneigh, tip_distance)
+        ]
+    end
+    non_tips, tips = neighbours_and_triples.partition{|nt| nt[1][0] == false}
+
+    visiteds = Set.new
+    process_tip = lambda do |tip|
+      visiteds << tip[0].to_settable
+      tip[1][2].each {|v| visiteds << v}
+    end
+
+    if non_tips.length > 0
+      tips.each do |tip|
+        process_tip.call tip
+      end
+      return non_tips.collect{|t| t[0]}, visiteds
+    else
+      # no long distances here. Just go with the longest path
+      best_tip = tips.max{|nt| nt[1][1]}
+      tips.each do |tip|
+        unless tip == best_tip
+          process_tip.call tip
+        end
+      end
+      return [best_tip[0]], visiteds
+    end
+  end
+
+  # Returns false iff there is a path longer than max_tip_length
+  # starting at the given oriented_node. Currently works as a depth
+  # first search, which may or may not be optimal
+  def is_short_tip?(oriented_node)
+    max_tip_length = @assembly_options[:max_tip_length]
+    is_tip, max_distance, visited_onodes = find_tip_distance(oriented_node, max_tip_length)
+    return is_tip, visited_onodes
+  end
+
+  # The workhorse function of is_short_tip?
+  #
+  #
+  def find_tip_distance(oriented_node, max_tip_length)
+    stack = DS::Stack.new
+    first = MaxDistancedOrientedNode.new
+    first.onode = oriented_node
+    first.distance = oriented_node.node.length_alone
+    stack.push first
+
+    cache = {}
+    max_dist = first.distance
+
+    while current_max_distanced_onode = stack.pop
+      if current_max_distanced_onode.distance > max_tip_length
+        return false, current_max_distanced_onode.distance, []
+      end
+
+      max_dist = [max_dist, current_max_distanced_onode.distance].max
+
+      current_max_distanced_onode.onode.next_neighbours(@graph).each do |oneigh|
+        neighbour_distance = current_max_distanced_onode.distance + oneigh.node.length_alone
+        next if cache[oneigh.to_settable] and cache[oneigh.to_settable] >= neighbour_distance
+        distanced_node = MaxDistancedOrientedNode.new
+        distanced_node.onode = oneigh
+        distanced_node.distance = neighbour_distance
+        log.debug "The distance of #{distanced_node.onode.node_id} is at least #{neighbour_distance}" if log.debug?
+        cache[oneigh.to_settable] = neighbour_distance
+        stack.push distanced_node
+      end
+    end
+
+    log.debug "Found insufficient max tip length #{max_dist} for #{oriented_node}" if log.debug?
+    return true, max_dist, cache.collect{|donode| donode[0]}
+  end
+
+  class MaxDistancedOrientedNode
+    attr_accessor :onode, :distance
+  end
+end