finishm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cde22b93c4ebc35cf5a598e1d4264104743e0168
+  data.tar.gz: 5e9b6e324cbe45329886c5fbf3e48236a76c0aa8
+SHA512:
+  metadata.gz: 5e2df4e2e7f9e1173d607bb7980189f942ca48980728945c57e50d0b9a15e110251ac22a93b289c94777d8277f79af381d2a4aa6957da981fd5b705c69a8674a
+  data.tar.gz: d3454311875a095f19da752d016b0bc954af6829d627480e416c071296103b59b9c448df335f53801d962f4a1c0433591ef16ce4bd5cc8e1f6c95133855f1435

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ext/src"]
+	path = ext/src
+	url = https://github.com/wwood/velvet

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,31 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem 'bio-ipcress'
+gem 'bio-logger'
+gem 'bio'
+gem 'progressbar'
+gem 'bio-samtools'
+gem 'ruby-graphviz'
+gem 'ds'
+gem 'hopcsv', '~> 0.4'
+gem 'bio-velvet', '~>0.6'
+gem 'bio-velvet_underground', '~>0.3'
+gem 'ruby-progressbar'
+gem 'yargraph', '~>0.0.4'
+
+#only needed temporarily until the bio-velvet gem is a proper dependency
+gem 'files'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.8.0"
+  gem "yard", ">= 0.7"
+  gem "rdoc", ">= 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem 'jeweler'
+  gem 'bio-commandeer'
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Ben J. Woodcroft
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+__WARNING__! FinishM is very alpha software and not ready for prime time. There are many unfinished parts of it, and many bugs. Please use with care, and don't judge the authors too harshly.
+
+# FinishM
+
+FinishM attempts to improve draft genomes by considering the computational problem to be about finishing, not assembly in the traditional sense.
+
+## A finishing approach to assembly
+Metagenome and isolate assemblers generate contigs from reads, but still leave valuable information on the table. FinishM exploits this information to improve/finish a draft genome without any further laboratory-based work.
+
+In even a moderately successful assembly, resultant contigs constitute the vast majority of the genome being sequenced, but this fact is ignored by assemblers. Unlike a traditional assembler FinishM does not attempt to directly extend contigs, but instead focuses on connecting already assembled contigs.
+
+FinishM has several modes:
+* Attempt to improve a genome. See `finishm roundup`. This mode fulfills both the `wander` and `gapfill` modes.
+* Determine which contig ends are connected in the assembly graph. See `finishm wander`.
+* FinishM 'gapfills' (replaces N characters) using a graph-theoretic approach that appears to outperform current gapfilling programs. See `finishm gapfill`.
+* Sometimes a human is better able to interpret an assembly graph than a machine. FinishM creates human interpretable graph visualisations that let humans solve assembly problems. See `finishm visualise`.
+* Some other experimental _de-novo_ (non-finishing) metagenome assembly techniques are implemented in `finishm assemble`.
+
+## Installation
+
+First, you'll need Ruby (FinishM is tested on 2.1). Then to install:
+```sh
+gem install finishm
+```
+
+FinishM also has some external dependencies:
+* clustalo (for `gapfilling`/`roundup`)
+* GraphViz (for the `visualise` mode)
+
+## Usage
+After installation, a listing of the modes and their usage:
+```sh
+finishm
+```
+
+## Developing
+To hack on finishm:
+```
+git clone https://github.com/wwood/finishm.git
+cd finishm
+bundle install
+git submodule update --init
+cd ext/src
+git checkout -b finishm origin/finishm #possibly this step is not required for newer versions of git
+make MAXKMERLENGTH=255 finishm velveth velvetg
+cp obj/shared/libfinishm.so.1.0 ../../lib/external/
+cd ../..
+./bin/finishm -h
+```
+
+## Citation
+
+A manuscript describing the tools described here is currently in preparation. However, FinishM reuses code from velvet and BioRuby, so these tools may be worth citing.
+
+## Copyright
+
+Copyright (c) 2012-2014 Ben J. Woodcroft. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "finishm"
+  gem.homepage = "http://github.com/wwood/finishm"
+  gem.license = "GPL"
+  gem.summary = %Q{Genome improvement and finishing with or without further sequencing effort}
+  gem.description = %Q{De-novo assemblies generally only provide draft genomes. FinishM is aimed at improving these draft assemblies.}
+  gem.email = "donttrustben near gmail.com"
+  gem.authors = ["Ben J. Woodcroft"]
+  # dependencies defined in Gemfile
+
+  gem.extensions = "ext/mkrf_conf.rb"
+
+  # by default, velvet as a git submodule is not included when making the gem
+  # but we need it to be.
+  gem.files.include "ext/src/src/*"
+  gem.files.include "ext/src/Makefile"
+  gem.files.include "ext/src/License"
+  gem.files.include "ext/src/third-party/**/*"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/assembly_visualiser

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'bio-logger'
+require 'bio-velvet'
+require 'graphviz'
+require 'bio'
+require 'set'
+
+SCRIPT_NAME = File.basename(__FILE__); LOG_NAME = 'finishm'
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+require 'priner'
+
+# Parse command line options into the options hash
+options = {
+  :logger => 'stderr',
+  :log_level => 'info',
+  :start_kmers => [],
+  :end_kmers => [],
+  :coverage_cutoff => 0.0,
+}
+o = OptionParser.new do |opts|
+  opts.banner = "
+    Usage: #{SCRIPT_NAME} --velvet-graph PreGraphFile [options]
+
+    Take a graph pre-computed with velveth, and output a GraphViz file for visualisation.
+
+    Overlayed on top of this graph can be added information e.g. nodes that contain
+    particular kmers get coloured.
+    \n\n"
+
+  opts.on("--velvet-graph GRAPH_FILE", "PreGraph file output from velveth [required]") do |arg|
+    options[:velvet_pregraph_file] = arg
+  end
+
+  opts.separator "\nOptional arguments:\n\n"
+  opts.on("--dot OUTPUT_DOT_FILENAME", "Output the graph into PNG format [default: not output as DOT]") do |arg|
+    options[:dot_output_file] = arg
+  end
+  opts.on("--png OUTPUT_PNG_FILENAME", "Output the graph into PNG format [default: not output as PNG]") do |arg|
+    options[:neato_png] = arg
+  end
+  opts.on("--start-kmers-file FILE", "Path to file containing newline-separated kmers that are associated with the start of the assembly [default: none]") do |arg|
+    options[:start_kmers] = File.open(arg).read.split(/\s+/)
+  end
+  opts.on("--end-kmers-file FILE", "Path to file containing newline-separated kmers that are associated with the end of the assembly [default: none]") do |arg|
+    options[:end_kmers] = File.open(arg).read.split(/\s+/)
+  end
+  opts.on("--coverage-cutoff NUMBER", "Require at least this much coverage, otherwise the node and associated edges are not shown in the output [default: #{options[:coverage_cutoff]}]") do |arg|
+    options[:coverage_cutoff] = arg.to_f
+  end
+
+  # logger options
+  opts.separator "\nVerbosity:\n\n"
+  opts.on("-q", "--quiet", "Run quietly, set logging to ERROR level [default INFO]") {options[:log_level] = 'error'}
+  opts.on("--logger filename",String,"Log to file [default #{options[:logger]}]") { |name| options[:logger] = name}
+  opts.on("--trace options",String,"Set log level [default INFO]. e.g. '--trace debug' to set logging level to DEBUG"){|s| options[:log_level] = s}
+end; o.parse!
+if ARGV.length != 0 or options[:velvet_pregraph_file].nil?
+  $stderr.puts o
+  exit 1
+end
+if !(options[:dot_output_file] or options[:neato_png])
+  $stderr.puts "Need to specify an output format with e.g. --png or --dot"
+  exit 1
+end
+# Setup logging
+Bio::Log::CLI.logger(options[:logger]); Bio::Log::CLI.trace(options[:log_level]); log = Bio::Log::LoggerPlus.new(LOG_NAME); Bio::Log::CLI.configure(LOG_NAME)
+
+
+log.info "Parsing graph from #{options[:velvet_pregraph_file]}"
+graph = Bio::Velvet::Graph.parse_from_file(options[:velvet_pregraph_file])
+log.info "Finished parsing graph, found #{graph.nodes.length} nodes and #{graph.arcs.length} arcs"
+
+if options[:start_kmers].length > 0
+  log.info "Read in #{options[:start_kmers].length} kmers associated with the start of the assembly"
+end
+if options[:end_kmers].length > 0
+  log.info "Read in #{options[:end_kmers].length} kmers associated with the end of the assembly"
+end
+list_of_start_kmers = options[:start_kmers].collect{|k| [k, Bio::Sequence::NA.new(k).reverse_complement.to_s]}.flatten
+list_of_end_kmers = options[:end_kmers].collect{|k| [k, Bio::Sequence::NA.new(k).reverse_complement.to_s]}.flatten
+
+if options[:coverage_cutoff]
+  cutter = Bio::AssemblyGraphAlgorithms::CoverageBasedGraphFilter.new
+  log.info "Removing low coverage (<#{options[:coverage_cutoff]}) nodes"
+  cutter.remove_low_coverage_nodes(graph, options[:coverage_cutoff])
+  log.info "After removing low coverage nodes, there is #{graph.nodes.length} nodes and #{graph.arcs.length} arcs"
+end
+
+viser = Bio::Assembly::ABVisualiser.new
+log.info "Converting assembly to GraphViz format"
+graphviz = viser.graphviz(graph, {:start_kmers => list_of_start_kmers, :end_kmers => list_of_end_kmers})
+
+# Print
+log.info "Printing assembly graph"
+if options[:dot_output_file]
+  graphviz.output :dot => options[:dot_output_file]
+end
+if options[:neato_png]
+  graphviz.output :png => options[:neato_png]
+end
+
+
+
+

data/bin/check_primer_combinations.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'bio-logger'
+
+$:.unshift File.join(ENV['HOME'],'git','bioruby-primer3','lib')
+require 'bio-primer3'
+
+if __FILE__ == $0 #needs to be removed if this script is distributed as part of a rubygem
+  SCRIPT_NAME = File.basename(__FILE__); LOG_NAME = SCRIPT_NAME.gsub('.rb','')
+  
+  # Parse command line options into the options hash
+  options = {
+    :logger => 'stderr',
+  }
+  o = OptionParser.new do |opts|
+    opts.banner = "
+      Usage: #{SCRIPT_NAME} -p1 <primer1> -f2 <primer_list_file>
+      
+      Uses primer3's \"check primers\" to find whether primers match against each other\n\n"
+      
+    opts.on("--primer1 PRIMER", "Primer on one side [required]") do |arg|
+      options[:primer1] = arg
+    end
+    opts.on("--primers2 PRIMER_FILE", "A list of primers in a file, newline separated [required]") do |arg|
+      options[:primers2_file] = arg
+    end
+
+    # logger options
+    opts.separator "\nVerbosity:\n\n"
+    opts.on("-q", "--quiet", "Run quietly, set logging to ERROR level [default INFO]") {Bio::Log::CLI.trace('error')}
+    opts.on("--logger filename",String,"Log to file [default #{options[:logger]}]") { |name| options[:logger] = name}
+    opts.on("--trace options",String,"Set log level [default INFO]. e.g. '--trace debug' to set logging level to DEBUG"){|s| Bio::Log::CLI.trace(s)}
+  end; o.parse!
+  if ARGV.length != 0
+    $stderr.puts o
+    exit 1
+  end
+  # Setup logging. bio-logger defaults to STDERR not STDOUT, I disagree
+  Bio::Log::CLI.logger(options[:logger]); log = Bio::Log::LoggerPlus.new(LOG_NAME); Bio::Log::CLI.configure(LOG_NAME)
+  
+  
+  # Read in input data
+  primers1 = [options[:primer1]]
+  primers2 = File.open(options[:primers2_file]).read.split("\n").collect{|c| c.strip}
+  log.info "Read in #{primers1.length} left primers and #{primers2.length} right primers e.g. #{primers1[0]} and #{primers2[0]}"
+  
+  goods = 0
+  bads = 0
+  failed_to_run = 0
+  primers1.each do |primer1|
+    primers2.each do |primer2|
+      begin
+        result, obj = Bio::Primer3.test_primer_compatibility primer1, primer2, 'PRIMER_EXPLAIN_FLAG'=>1
+        
+        puts [
+          primer1, primer2, result, obj['PRIMER_LEFT_EXPLAIN'], obj['PRIMER_RIGHT_EXPLAIN']
+        ].join "\t"
+        
+        if result
+          goods += 1
+        else
+          bads += 1
+        end
+        
+      rescue Exception => e
+        failed_to_run += 1
+      end
+    end
+  end
+  log.info "Found #{goods} OK primer pairs and #{bads} not OK primer pairs"
+  log.warn "#{failed_to_run} weren't checked by Primer3 because it failed to run" if failed_to_run > 0
+end #end if running as a script

data/bin/contig_joiner.rb

@@ -0,0 +1,244 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'bio-logger'
+require 'bio-velvet'
+require 'tempfile'
+require 'pp'
+
+SCRIPT_NAME = File.basename(__FILE__); LOG_NAME = 'finishm'
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+require 'priner'
+
+# Parse command line options into the options hash
+options = {
+  :logger => 'stderr',
+  :log_level => 'info',
+  :velvet_kmer_size => 73,#TODO: these options should be exposed to the user, and perhaps not guessed at
+  :velvetg_arguments => '-read_trkg yes',# -exp_cov 41 -cov_cutoff 12.0973243610491', #hack
+  :contig_end_length => 300,
+  :output_assembly_path => 'velvetAssembly',
+  :graph_search_leash_length => 3000,
+}
+o = OptionParser.new do |opts|
+  opts.banner = "
+    Usage: #{SCRIPT_NAME} --reads <read_file> --contigs <contigs_file>
+
+    Takes a set of reads and a set of contigs. Then it runs an assembly based on those reads,
+    and tries to fill in possible gaps between the contigs. There may be multiple ways
+    to join two contig ends together - in this that multiple cases are reported. \n\n"
+
+
+  opts.on("--reads FILE", "gzipped fastq file of reads to perform the re-assembly with [required]") do |arg|
+    options[:reads_file] = arg
+  end
+  opts.on("--contigs FILE", "fasta file of contigs to be joined together [required]") do |arg|
+    options[:contigs_file] = arg
+  end
+
+  opts.separator "\nOptional arguments:\n\n"
+  opts.on("--output-trails-fasta PATH", "Output found paths to this file in fasta format [default: off]") do |arg|
+    options[:overall_trail_output_fasta_file] = arg
+  end
+  opts.on("--already-assembled-velvet-directory PATH", "Skip until after assembly in this process, and start from this assembly directory created during a previous run of this script [default: off]") do |arg|
+    options[:previous_assembly] = arg
+  end
+  opts.on("--serialize-velvet-graph FILE", "So that the velvet graph does not have to be reparsed, serialise the parsed object for later use in this file [default: off]") do |arg|
+    options[:serialize_parsed_graph_file] = arg
+  end
+  opts.on("--already-serialized-velvet-graph FILE", "Restore the parsed velvet graph from this file [default: off]") do |arg|
+    options[:previously_serialized_parsed_graph_file] = arg
+  end
+
+
+  # logger options
+  opts.separator "\nVerbosity:\n\n"
+  opts.on("-q", "--quiet", "Run quietly, set logging to ERROR level [default INFO]") {options[:log_level] = 'error'}
+  opts.on("--logger filename",String,"Log to file [default #{options[:logger]}]") { |name| options[:logger] = name}
+  opts.on("--trace options",String,"Set log level [default INFO]. e.g. '--trace debug' to set logging level to DEBUG"){|s| options[:log_level] = s}
+end; o.parse!
+if ARGV.length != 0 or options[:reads_file].nil? or options[:contigs_file].nil?
+  $stderr.puts o
+  exit 1
+end
+# Setup logging
+Bio::Log::CLI.logger(options[:logger]); Bio::Log::CLI.trace(options[:log_level]); log = Bio::Log::LoggerPlus.new(LOG_NAME); Bio::Log::CLI.configure(LOG_NAME)
+Bio::Log::LoggerPlus.new 'bio-velvet'; Bio::Log::CLI.configure 'bio-velvet'
+
+# Extract contig ends from each of the input contigs, so that the contig ends can be found in the
+# assembly graph structure.
+contig_ends = []
+velvet_sequence_id_to_contig_end = {}
+contig_lengths = {}
+class ContigEnd
+  attr_accessor :sequence, :start_or_end, :contig_name, :velvet_sequence_id
+end
+velvet_read_index = 1
+Bio::FlatFile.foreach(options[:contigs_file]) do |seq|
+  contig_lengths[seq.definition] = seq.seq.length
+  if seq.seq.length < options[:contig_end_length]
+    log.warn "Contig #{seq.definition} is shorter than the end length used to anchor the contig in the assembly. This is not ideal but may be ok."
+    #TODO: fix this - should be counting from the middle. Should I just ignore those ones?
+  end
+  # Add the start of the contig
+  contig_end = ContigEnd.new
+  contig_end.start_or_end = :start
+  contig_end.sequence = Bio::Sequence::NA.new(seq.seq[0...options[:contig_end_length]]).reverse_complement.to_s
+  contig_end.contig_name = seq.definition
+  velvet_sequence_id_to_contig_end[velvet_read_index] = contig_end
+  contig_end.velvet_sequence_id = velvet_read_index; velvet_read_index += 1
+  contig_ends.push contig_end
+
+
+  # Add the back of the contig
+  contig_end = ContigEnd.new
+  contig_end.start_or_end = :end
+  s = seq.seq
+  contig_end.sequence = s[s.length-options[:contig_end_length]...s.length]
+  contig_end.contig_name = seq.definition
+  velvet_sequence_id_to_contig_end[velvet_read_index] = contig_end
+  contig_end.velvet_sequence_id = velvet_read_index; velvet_read_index += 1
+  contig_ends.push contig_end
+end
+log.info "Parsed in #{contig_ends.length} contig ends from the two sides of each input contig"
+
+
+graph = nil
+if options[:previously_serialized_parsed_graph_file].nil?
+  velvet_result = nil
+  if options[:previous_assembly].nil? #If assembly has not already been carried out
+    Tempfile.open('anchors.fa') do |tempfile|
+      contig_ends.each do |contig_end|
+        tempfile.puts ">anchor#{contig_end.velvet_sequence_id}"
+        tempfile.puts contig_end.sequence
+      end
+
+      log.info "Assembling sampled reads with velvet"
+      # Bit of a hack, but have to use -short1 as the anchors because then start and end anchors will have node IDs 1,2,... etc.
+      velvet_result = Bio::Velvet::Runner.new.velvet(
+        options[:velvet_kmer_size],
+        "-short #{tempfile.path} -short2 -fastq.gz #{options[:reads_file]}",
+        options[:velvetg_arguments],
+        :output_assembly_path => options[:output_assembly_path]
+      )
+      if log.debug?
+        log.debug "velveth stdout: #{velvet_result.velveth_stdout}"
+        log.debug "velveth stderr: #{velvet_result.velveth_stderr}"
+        log.debug "velvetg stdout: #{velvet_result.velvetg_stdout}"
+        log.debug "velvetg stderr: #{velvet_result.velvetg_stderr}"
+      end
+      log.info "Finished running assembly"
+    end
+  else
+    log.info "Using previous assembly stored at #{options[:previous_assembly]}"
+    velvet_result = Bio::Velvet::Result.new
+    velvet_result.result_directory = options[:previous_assembly]
+  end
+
+  require 'ruby-prof'
+  RubyProf.start
+
+  log.info "Parsing the graph output from velvet"
+  graph = Bio::Velvet::Graph.parse_from_file(File.join velvet_result.result_directory, 'Graph2')
+  log.info "Finished parsing graph: found #{graph.nodes.length} nodes and #{graph.arcs.length} arcs"
+
+  result = RubyProf.stop
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+
+  if options[:serialize_parsed_graph_file]
+    log.info "Storing a binary version of the graph file for later use at #{options[:serialize_parsed_graph_file]}"
+    File.open(options[:serialize_parsed_graph_file],'wb') do |f|
+      f.print Marshal.dump(graph)
+    end
+    log.info "Stored a binary representation of the velvet graph at #{options[:serialize_parsed_graph_file]}"
+  end
+else
+  log.info "Restoring graph file from #{options[:previously_serialized_parsed_graph_file]}.."
+  graph = Marshal.load(File.open(options[:previously_serialized_parsed_graph_file]))
+  log.info "Restoration complete"
+end
+
+
+
+# Find the anchoring nodes for each of the contig ends
+finder = Bio::AssemblyGraphAlgorithms::NodeFinder.new
+log.info "Finding node representing the end of the each contig"
+i = 1
+anchor_sequence_ids = contig_ends.collect{|c| c.velvet_sequence_id}
+anchoring_nodes_and_directions = finder.find_unique_nodes_with_sequence_ids(graph, anchor_sequence_ids)
+num_anchors_found = anchoring_nodes_and_directions.reject{|s,e| e[0].nil?}.length
+anchoring_node_id_to_contig_end = {}
+anchoring_nodes_and_directions.each do |seq_id, node_and_direction|
+  next if node_and_direction[0].nil? #skip when there is no node found in the graph for this contig end
+  anchoring_node_id_to_contig_end[node_and_direction[0].node_id] = velvet_sequence_id_to_contig_end[seq_id]
+end
+log.info "Found anchoring nodes for #{num_anchors_found} out of #{contig_ends.length} contig ends"
+
+log.info "Searching for trails between the nodes within the assembly graph"
+cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+trail_sets = cartographer.find_trails_between_node_set(graph, anchoring_nodes_and_directions.values.reject{|v| v[0].nil?}, options[:graph_search_leash_length])
+log.info "Found #{trail_sets.reduce(0){|s,set|s+=set.length}} trail(s) in total"
+
+node_id_to_contig_description = {}
+anchoring_nodes_and_directions.each do |seq_id, pair|
+  next if pair.empty? #When no nodes were found
+  node_id = pair[0].node_id
+  node_id_to_contig_description[node_id] = velvet_sequence_id_to_contig_end[seq_id]
+end
+contig_end_id_to_partners = {}
+# Tabulate all the partners each way (complete the previously triangular matrix)
+trail_sets.each do |trail_set|
+  trail_set.each do |trail|
+    start_id = trail.first.node.node_id
+    end_id = trail.last.node.node_id
+    contig_end_id_to_partners[start_id] ||= []
+    contig_end_id_to_partners[start_id].push node_id_to_contig_description[end_id]
+    contig_end_id_to_partners[end_id] ||= []
+    contig_end_id_to_partners[end_id].push node_id_to_contig_description[start_id]
+  end
+end
+
+puts %w(contig_end_id contig_name contig_length connections).join "\t"
+trail_sets.each_with_index do |trail_set, i|
+  partner_contig_ends = contig_end_id_to_partners[contig_ends[i].velvet_sequence_id]
+  partner_contig_ends ||= []
+  # Each contig has 2 trail sets associated with it - one for the start and one for the end
+  puts [
+    contig_ends[i].velvet_sequence_id,
+    contig_ends[i].contig_name,
+    contig_lengths[contig_ends[i].contig_name],
+    partner_contig_ends.collect{|c| c.velvet_sequence_id}.sort.join(',')
+  ].join("\t")
+end
+
+if options[:overall_trail_output_fasta_file]
+  File.open(options[:overall_trail_output_fasta_file],'w') do |outfile|
+    trail_sets.each do |trail_set|
+      trail_set.each do |trail|
+        begin
+          trail_sequence = trail.sequence #Get the trail sequence first as this may not be possible.
+
+          start_id = trail.first.node.node_id
+          end_id = trail.last.node.node_id
+          start_contig_end = anchoring_node_id_to_contig_end[start_id]
+          end_contig_end = anchoring_node_id_to_contig_end[end_id]
+          outfile.print '>'
+          outfile.print start_contig_end.contig_name
+          outfile.print '_'
+          outfile.print start_contig_end.start_or_end
+          outfile.print ':'
+          outfile.print end_contig_end.contig_name
+          outfile.print '_'
+          outfile.puts end_contig_end.start_or_end
+
+          outfile.puts trail_sequence
+        rescue Bio::Velvet::NotImplementedException => e
+          log.warn "Problem getting sequence of found trail #{trail.to_s}, skipping this trail: #{e.to_s}"
+        end
+      end
+    end
+  end
+end
+
+