finishm 0.0.1

data/bin/contigs_against_assembly.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'bio-logger'
+require 'systemu'
+
+SCRIPT_NAME = File.basename(__FILE__); LOG_NAME = SCRIPT_NAME.gsub('.rb','')
+
+# Parse command line options into the options hash
+options = {
+  :logger => 'stderr',
+  :log_level => 'info',
+}
+o = OptionParser.new do |opts|
+  opts.banner = "
+    Usage: #{SCRIPT_NAME} -b <contigs_against_assembly.blast_outfmt6.csv>
+
+    Takes a set of contigs, and an assembly. Works out if there are any contigs where there is a blast hit spanning of the contigs using two of the assembly's contig ends.\n\n"
+
+  opts.on("--query FASTA_FILE", "new contigs fasta file [Required]") do |arg|
+    options[:query_file] = arg
+  end
+  opts.on("--blastdb FASTA_FILE_FORMATTED", "basename of makeblastdb output [Required]") do |arg|
+    options[:blastdb] = 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[:query_file].nil? or options[:blastdb].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)
+
+
+# Read in the blast file
+blast_results = []
+class BlastResult
+  attr_accessor :qseqid, :sseqid, :pident, :length, :mismatch, :gapopen, :qstart, :qend, :sstart, :subject_end, :evalue, :bitscore, :query_length, :subject_length
+
+  attr_accessor :cutoff_inwards
+
+  def initialize
+    @cutoff_inwards = 500
+  end
+
+  def hits_end_of_subject?
+    @subject_end >= @subject_length-@cutoff_inwards and @length >= 100
+  end
+
+  def hits_start_of_subject?
+    @sstart <= @cutoff_inwards and @length >= 100
+  end
+
+  def hits_end_of_query?
+    @qend >= @query_length-@cutoff_inwards and @length >= 100
+  end
+
+  def hits_start_of_query?
+    @qstart <= @cutoff_inwards and @length >= 100
+  end
+end
+
+status, blast_output, stderr = systemu "blastn -query #{options[:query_file].inspect} -db #{options[:blastdb].inspect} -outfmt '6 qseqid sseqid pident length mismatch gapopen qstart qend sstart send evalue bitscore qlen slen' -evalue 1e-5"
+raise stderr unless stderr==""
+raise "bad status running blast" unless status.exitstatus == 0
+log.debug "Finished running blast, presumably successfully"
+
+blast_output.each_line do |line|
+  res = BlastResult.new
+  row = line.chomp.split "\t"
+  [:qseqid, :sseqid, :pident, :length, :mismatch, :gapopen, :qstart,
+  :qend, :sstart, :subject_end, :evalue, :bitscore,
+  :query_length, :subject_length].each_with_index do |attr, i|
+    res.send "#{attr}=".to_sym, row[i]
+  end
+  [:length, :mismatch, :gapopen, :qstart,
+  :qend, :sstart, :subject_end,:query_length, :subject_length].each do |attr|
+    res.send "#{attr}=".to_sym, res.send(attr).to_i
+  end
+  [:pident, :evalue, :bitscore].each do |attr|
+    res.send "#{attr}=".to_sym, res.send(attr).to_f
+  end
+
+  blast_results.push res
+end
+log.info "Parsed #{blast_results.length} blast results e.g. #{blast_results[0].inspect}"
+
+
+query_to_blast_results = {}
+hit_to_blast_results = {}
+blast_results.each do |result|
+  query_to_blast_results[result.qseqid] ||= []
+  query_to_blast_results[result.qseqid].push result
+
+  hit_to_blast_results[result.sseqid] ||= []
+  hit_to_blast_results[result.sseqid].push result
+end
+
+# For each query sequence, does it map to the ends of both contigs
+header = %w(query subject1 subject2 qstart1? qend1? sstart1? send1? qstart2? qend2? sstart2? send2?).join("\t")
+query_to_blast_results.each do |query_id, hits|
+  query_length = hits[0].query_length
+  keepers = []
+
+  hits.each do |hit|
+    # perfect if it hits the start or the end (but not both) of both the query and the subject, unless it is circular
+    if hit.hits_start_of_query? ^ hit.hits_end_of_query? and
+      hit.hits_start_of_subject? ^ hit.hits_end_of_subject?
+      keepers.push hit
+    elsif hit.hits_start_of_query? or hit.hits_end_of_query? or
+      hit.hits_start_of_subject? or hit.hits_end_of_subject?
+      log.info "There's a half-correct hit for #{query_id}: qstart? #{hit.hits_start_of_query?} qend #{hit.hits_end_of_query?} "+
+        "sstart #{hit.hits_start_of_subject?} send #{hit.hits_end_of_subject?}, to subject sequence #{hit.sseqid}"
+    end
+  end
+
+  if keepers.empty?
+    log.debug "no latchings found for #{query_id}"
+  elsif keepers.length == 1
+    log.info "Query #{query_id} only latches on to a single end, maybe manually inspect"
+  elsif keepers.length == 2
+    log.debug "Query #{query_id} has 2 keepers!"
+    q = keepers.collect{|hit| hit.hits_start_of_query?}.join
+    s = keepers.collect{|hit| hit.hits_start_of_subject?}.join
+    if (q == 'truefalse' or q == 'falsetrue') and
+      (s == 'truefalse' or s == 'falsetrue')
+      outs = (0..1).collect{|i|
+        [
+          keepers[i].hits_start_of_query?,
+          keepers[i].hits_end_of_query?,
+          keepers[i].hits_start_of_subject?,
+          keepers[i].hits_end_of_subject?,
+        ]
+      }.flatten
+      unless header.nil?
+        puts header
+        header = nil
+      end
+      puts [query_id, keepers[0].sseqid, keepers[1].sseqid, outs].flatten.join("\t")
+    else
+      log.info "Query #{query_id} has 2 keepers, but they are fighting it seems"
+    end
+  else
+    log.info "More than 2 keepers found for #{query_id}, manual inspection likely required"
+  end
+end
+

data/bin/finishm

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'bio-logger'
+require 'bio-velvet'
+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',
+}
+global = OptionParser.new do |opts|
+  opts.banner = "
+    Usage: #{SCRIPT_NAME} <command> [<arguments>]
+
+  FinishM is a collection of tasks related to assembly and metagenome assembly. Available commands:
+
+    wander\tTry to connect contigs (experimental)
+    gapfill\tFill assembly gaps (N characters) (experimental)
+    explore\tWhat happens in the graph beyond the end of my contig(s)? (experimental)
+    visualise\tVisualise the DeBruijn graph (experimental)
+
+  Commands for PCR finishing:
+
+    primers\tdesign primers for multi-primer multi-lane PCR experimental setup (experimental)
+    primers_check\ttest a set of primers for incompatibility (experimental)
+    finish\tprocess results from multi-primer multi-lane PCR experimental setup (experimental)
+
+  Utility modes:
+
+    sequence\tGiven a defined sequence of nodes, what is the corresponding sequence?
+    count_paths\tCount the number of paths through assembly graph
+    find_orfs\tFind possible open reading frames in assembly graph
+    \n\n"
+end
+global.order!
+
+operator = nil
+subcommands = {
+  'primers' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Primers.new
+    operator.add_options(opts, options)
+  end},
+  'primers_check' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Primers::Checker.new
+    operator.add_options(opts, options)
+  end},
+  'finish' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Finisher.new
+    operator.add_options(opts, options)
+  end},
+  'gapfill' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::GapFiller.new
+    operator.add_options(opts, options)
+  end},
+  'wander' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Wanderer.new
+    operator.add_options(opts, options)
+  end},
+  'fluff' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Fluff.new
+    operator.add_options(opts, options)
+  end},
+  'explore' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Explorer.new
+    operator.add_options(opts, options)
+  end},
+  'assemble' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Assembler.new
+    operator.add_options(opts, options)
+  end},
+  'visualise' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Visualise.new
+    operator.add_options(opts, options)
+  end},
+  'sequence' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::Sequence.new
+    operator.add_options(opts, options)
+  end},
+  'roundup' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::RoundUp.new
+    operator.add_options(opts, options)
+  end},
+  'count_paths' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::PathCounter.new
+    operator.add_options(opts, options)
+  end},
+  'find_orfs' => lambda {OptionParser.new do |opts|
+    operator = Bio::FinishM::ORFsFinder.new
+    operator.add_options(opts, options)
+  end}
+}
+
+subcommand = nil
+if ARGV[0] and ARGV[0].match(/finishm$/) #if debugging e.g. 'pry finishm wander ..'. But be careful of finishm no arguments
+  subcommand = ARGV.shift
+  subcommand = ARGV.shift
+else
+  # not debugging
+  subcommand = ARGV.shift
+end
+
+if subcommand.nil?
+  $stderr.puts global
+  exit 1
+elsif !subcommands[subcommand]
+  $stderr.puts "Unrecognized subcommand: #{subcommand}"
+  exit 1
+else
+  # Add options specific for subcommand
+  opts = subcommands[subcommand].call
+
+  # Add global logging 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}
+  opts.separator "\n"
+  opts.parse!
+
+  # 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.outputters.each {|o| o.formatter = Log4r::PatternFormatter.new(:pattern => "%5l %c %d: %m", :date_pattern => '%d/%m %T')}
+  Bio::Log::LoggerPlus.new 'bio-velvet'; Bio::Log::CLI.configure 'bio-velvet'
+
+  log.debug "Running FinishM #{subcommand} with these options: #{PP.pp(options, "").gsub(/\n$/,'')}"
+
+  error_message = operator.validate_options(options, ARGV)
+  if error_message.nil? or error_message == false
+    operator.run options, ARGV
+  else
+    $stderr.puts
+    $stderr.puts "ERROR parsing options: #{error_message}"
+    $stderr.puts
+    $stderr.puts opts
+    exit 1
+  end
+end
+

data/bin/finishm_assembler

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'bio-logger'
+
+SCRIPT_NAME = File.basename(__FILE__); LOG_NAME = SCRIPT_NAME.gsub('.rb','')
+
+# Parse command line options into the options hash
+options = {
+  :logger => 'stderr',
+  :log_level => 'info',
+}
+o = OptionParser.new do |opts|
+  opts.banner = "
+    Usage: #{SCRIPT_NAME} <arguments>
+
+    Description of what this program does...\n\n"
+
+  opts.on("--velvet-pregraph GRAPH_FILE", "PreGraph file output from velveth [required]") do |arg|
+    options[:velvet_pregraph_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[:velvet_pregraph_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)
+
+
+# Read in the velvet graph
+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.number_of_nodes} nodes"
+
+# Log the number of nodes and arcs in the current graph
+
+# Read in the fasta file of immutable nodes, and extract the two most immutable
+# Log that they are found
+
+# Determine that the graph is connected or not between the two most immutable nodes, using some graph theoretic algorithm
+# If the graph is not connected, then there is no hope, exit
+
+# Go through the graph to get a list of the cap nodes
+# Log the number of cap nodes found
+
+# Trim off all the cap nodes back to cross nodes, keeping track of the lengths
+
+# Print the graph in graphviz dot format

data/bin/finishm_gap_closer.rb

@@ -0,0 +1,241 @@
+#!/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 => 43,#TODO: these options should be exposed to the user, and perhaps not guessed at
+  :contig_end_length => 200,
+  :output_assembly_path => '/tmp/velvetAssembly',
+  :graph_search_leash_length => 3000,
+  :assembly_coverage_cutoff => 1.5,
+}
+o = OptionParser.new do |opts|
+  opts.banner = "
+    Usage: #{SCRIPT_NAME} --reads <read_file> --contig <contig_file>
+
+    Takes a set of reads and a contig that contains gap characters. Then it tries to fill in
+    these N characters. It is possible that there is multiple ways to close the gap - in that case
+    each is reported. \n\n"
+
+
+  opts.on("--reads FILE", "gzipped fastq file of reads to perform the gap closing with [required]") do |arg|
+    options[:reads_file] = arg
+  end
+  opts.on("--contig FILE", "fasta file of single contig containing Ns that are to be closed [required]") do |arg|
+    options[:contig_file] = arg
+  end
+  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.separator "\nOptional arguments:\n\n"
+  opts.on("--overhang NUM", "Start assembling this far from the gap [default: #{options[:contig_end_length]}]") do |arg|
+    options[:contig_end_length] = arg.to_i
+  end
+  opts.on("--start OFFSET", "Start trying to fill from this position in the contig, requires --stop [default: found from position of Ns}]") do |arg|
+    options[:start_offset] = arg.to_i-1
+  end
+  opts.on("--stop OFFSET", "Start trying to fill to this position in the contig, requires --start [default: found from position of Ns}]") do |arg|
+    options[:end_offset] = arg.to_i-1
+  end
+  opts.on("--assembly-png PATH", "Output assembly as a PNG file [default: off]") do |arg|
+    options[:output_graph_png] = arg
+  end
+  opts.on("--assembly-svg PATH", "Output assembly as an SVG file [default: off]") do |arg|
+    options[:output_graph_svg] = arg
+  end
+  opts.on("--assembly-dot PATH", "Output assembly as an DOT file [default: off]") do |arg|
+    options[:output_graph_dot] = arg
+  end
+  opts.on("--velvet-kmer KMER", "kmer size to use with velvet [default: #{options[:velvet_kmer_size]}]") do |arg|
+    options[:velvet_kmer_size] = arg.to_i
+  end
+
+  opts.separator "\nDebug-related options:\n\n"
+
+
+
+  # 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[:contig_file].nil? or options[:overall_trail_output_fasta_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'
+log.outputters[0].formatter = Log4r::PatternFormatter.new(:pattern => "%5l %c %d: %m", :date_pattern => '%d/%m %T')
+
+log.debug "Running finishm with options: #{PP.pp(options, "").gsub(/\n$/,'')}" if log.debug?
+
+# Find where the Ns are
+n_region_start = nil
+n_region_end = nil
+sequence = nil
+Bio::FlatFile.foreach(options[:contig_file]) do |seq|
+  if sequence
+    raise Exception, "Sorry, this script can only handle single sequences to be gap filled at the moment"
+  end
+
+  sequence = seq.seq
+
+  if options[:start_offset] and options[:end_offset]
+    log.info "Trying to gap fill from #{options[:start_offset]+1} to #{options[:end_offset]+1}"
+    n_region_start = options[:start_offset]
+    n_region_end = options[:end_offset]
+  else
+    log.info "Determining where to fill from the presence of Ns"
+
+    matches = sequence.match(/(N+)/i)
+    if !matches
+      raise "Unable to find any gaps in the input sequence. That was a bit too easy.."
+    end
+    n_region_start = matches.offset(0)[0]
+    n_region_end = n_region_start + matches[1].length
+    log.info "Detected a gap between #{n_region_start} and #{n_region_end}"
+  end
+
+  # Check to make sure we are sufficiently distant from the ends
+  if n_region_start < options[:contig_end_length] or
+    sequence.length - n_region_end < options[:contig_end_length]
+    raise "The gap is too close to the end of the contig, sorry"
+  end
+end
+
+# Do the assembly
+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|
+      tempfile.puts ">anchor1"
+      tempfile.puts sequence[n_region_start-options[:contig_end_length]-1...n_region_start]
+      tempfile.puts ">anchor2"
+      #Have to be in reverse, because the node finder finds the node at the start of the read, not the end
+      fwd2 = Bio::Sequence::NA.new(sequence[n_region_end..(n_region_end+options[:contig_end_length])])
+      tempfile.puts fwd2.reverse_complement.to_s
+      tempfile.close
+      log.debug "Inputting anchors into the assembly: #{File.open(tempfile.path).read}" if log.debug?
+
+      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]}",
+        "-read_trkg yes -cov_cutoff #{options[:assembly_coverage_cutoff]}",
+        :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
+
+  log.info "Parsing the graph output from velvet"
+  graph = Bio::Velvet::Graph.parse_from_file(File.join velvet_result.result_directory, 'LastGraph')
+  log.info "Finished parsing graph: found #{graph.nodes.length} nodes and #{graph.arcs.length} arcs"
+
+  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
+
+  if options[:assembly_coverage_cutoff]
+    log.info "Removing low-coverage nodes from the graph (less than #{options[:assembly_coverage_cutoff]})"
+    cutoffer = Bio::AssemblyGraphAlgorithms::CoverageBasedGraphFilter.new
+    deleted_nodes, deleted_arcs = cutoffer.remove_low_coverage_nodes(graph, options[:assembly_coverage_cutoff], :whitelisted_sequences => [1,2])
+
+    log.info "Removed #{deleted_nodes.length} nodes and #{deleted_arcs.length} arcs from the graph due to low coverage"
+    log.info "Now there is #{graph.nodes.length} nodes and #{graph.arcs.length} arcs remaining"
+  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 anchor nodes again
+finder = Bio::AssemblyGraphAlgorithms::NodeFinder.new
+log.info "Finding node representing the end of the each contig"
+i = 1
+anchor_sequence_ids = [1,2]
+start_node, start_node_forward  = finder.find_unique_node_with_sequence_id(graph, 1)
+end_node, end_node_forward  = finder.find_unique_node_with_sequence_id(graph, 2)
+if start_node and end_node
+  log.info "Found both anchoring nodes in the graph: #{start_node.node_id}/#{start_node_forward} and #{end_node.node_id}/#{end_node_forward}"
+else
+  log.error "start node not found" if start_node.nil?
+  log.error "end node not found" if end_node.nil?
+  raise "Unable to find both anchor reads from the assembly, cannot continue. This is probably an error with this script, not you."
+end
+
+log.info "Removing nodes unconnected to either the start or the end from the graph.."
+original_num_nodes = graph.nodes.length
+original_num_arcs = graph.arcs.length
+filter = Bio::AssemblyGraphAlgorithms::ConnectivityBasedGraphFilter.new
+filter.remove_unconnected_nodes(graph, [start_node, end_node])
+log.info "Removed #{original_num_nodes-graph.nodes.length} nodes and #{original_num_arcs-graph.arcs.length} arcs"
+
+
+if options[:output_graph_png]
+  log.info "Converting assembly to a graphviz PNG"
+  viser = Bio::Assembly::ABVisualiser.new
+  gv = viser.graphviz(graph, {:start_node_id => start_node.node_id, :end_node_id => end_node.node_id})
+  gv.output :png => options[:output_graph_png], :use => :neato
+end
+if options[:output_graph_svg]
+  log.info "Converting assembly to a graphviz SVG"
+  viser = Bio::Assembly::ABVisualiser.new
+  gv = viser.graphviz(graph, {:start_node_id => start_node.node_id, :end_node_id => end_node.node_id})
+  gv.output :svg => options[:output_graph_svg], :use => :neato
+end
+if options[:output_graph_dot]
+  log.info "Converting assembly to a graphviz DOT"
+  viser = Bio::Assembly::ABVisualiser.new
+  gv = viser.graphviz(graph, {:start_node_id => start_node.node_id, :end_node_id => end_node.node_id, :digraph => false})
+  gv.output :dot => options[:output_graph_dot]
+end
+
+
+
+log.info "Searching for trails between the nodes within the assembly graph"
+cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
+trails = cartographer.find_trails_between_nodes(graph, start_node, end_node, options[:graph_search_leash_length], start_node_forward)
+log.info "Found #{trails.length} trail(s) in total"
+
+
+log.debug "Outputing trail sequences"
+File.open(options[:overall_trail_output_fasta_file],'w') do |f|
+  trails.each_with_index do |trail, i|
+    f.puts ">trail#{i+1}"
+    f.puts trail.sequence
+  end
+end
+