finishm 0.0.1 → 0.0.2

data/bin/finishm_assembler

@@ -1,55 +0,0 @@
-#!/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

@@ -1,241 +0,0 @@
-#!/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
-

data/bin/kmer_abundance_file_tool.rb

@@ -1,49 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'bio-logger'
-require 'csv'
-
-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',
-  :min => 0,
-}
-o = OptionParser.new do |opts|
-  opts.banner = "
-    Usage: #{SCRIPT_NAME} <arguments>
-
-    grep a multiple kmer abundance file according to specified criteria\n\n"
-
-  opts.on("--min NUMBER", "At least 1 column has at least this many observations [default: #{options[:min]}]") do |arg|
-    options[:min] = 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 != 1
-  $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)
-
-CSV.foreach(ARGV[0], :col_sep => ' ') do |row|
-  kmer = row[0]
-  passable = false
-  row[1...row.length].each do |count|
-    if count.to_f > options[:min]
-      passable = true
-      break
-    end
-  end
-  puts row.join(' ') if passable
-end
-

data/bin/kmer_pattern_to_assembly.rb

@@ -1,377 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'bio-logger'
-require 'csv'
-require 'tempfile'
-require 'pp'
-require 'systemu'
-require 'bio-velvet'
-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',
-  :min_leftover_length => false,
-  :kmer_coverage_target => 1,
-  :velvet_kmer_size => 155,
-  :contig_end_length => 300,
-  :graph_search_leash_length => 20000,
-  :reads_to_assemble => nil,
-  :assembly_coverage_cutoff => 1.5,
-  :kmer_path_filter_min_coverage => 1,
-  :kmer_path_end_exclusion_length => 50,
-  :trail_kmer_coverage_file => 'trail_coverages.csv'
-}
-
-# TODO: make a better interface for this. Maybe specify an entire genome, and then "Contig_1 end, Contig_3 start" or something
-# Look at the last 300bp of the first contig.
-extract_exactly_one_contig_from_file = lambda do |fasta_file_path|
-  contig = nil
-  Bio::FlatFile.foreach(Bio::FastaFormat, fasta_file_path) do |e|
-    if contig.nil?
-      contig = e.seq
-    else
-      raise "Multiple sequences found in a contig file! I need exactly one"
-    end
-  end
-  raise "I need a contig to be in the start contig file" if contig.nil?
-  Bio::Sequence::NA.new(contig.to_s)
-end
-
-o = OptionParser.new do |opts|
-  opts.banner = "
-    Usage: #{SCRIPT_NAME} <kmer_multiple_abundance_file>
-
-    Given an input kmer then abundances space separated file, and a threshold, print out how many kmers are unique to different subsets of columns\n\n"
-
-  opts.on("--pattern PATTERN", "kmer abundance pattern e.g. '0111001110' [required]") do |arg|
-    options[:pattern] = arg
-  end
-  opts.on("--kmer-abundances FILE", "kmer multiple abundance file [required]") do |arg|
-    options[:kmer_multiple_abundance_file] = arg
-  end
-  opts.on("--upper-threshold NUM", "kmer frequency cutoff to saying 'present' [required]") do |arg|
-    options[:upper_threshold] = arg.to_i
-  end
-  opts.on("--lower-threshold NUM", "kmer frequency cutoff to saying 'not present' [required]") do |arg|
-    options[:lower_threshold] = arg.to_i
-  end
-  opts.on("--reads FILES", "comma-separated list of sequence reads files in the same order as the pattern was supplied [required]") do |arg|
-    options[:reads_files] = arg.split(',').collect{|r| File.absolute_path r}
-  end
-  opts.on("--start-contig FASTA", "path to a fasta file with the starting contig in it (only). Assumes we are building off the end of this contig [required]") do |arg|
-    options[:start_contig] = extract_exactly_one_contig_from_file.call arg
-  end
-  opts.on("--end-contig FASTA", "path to a fasta file with the ending contig in it (only). Assumes we are building onto the start of this contig [required]") do |arg|
-    options[:end_contig] = extract_exactly_one_contig_from_file.call arg
-  end
-
-  opts.separator "\nOptional arguments:\n\n"
-  opts.on("--min-leftover-read-length NUMBER", "when searching for reads with kmers, require the kmer to be at the beginning or end of the selected read [default: #{options[:min_leftover_length]}]") do |arg|
-    options[:min_leftover_length] = arg.to_i
-  end
-  opts.on("--kmer-coverage-target NUMBER", "when searching for reads with kmers, require this many copies per kmer [default: #{options[:kmer_coverage_target]}]") do |arg|
-    options[:kmer_coverage_target] = arg.to_i
-  end
-  opts.on("--already-patterned-reads FILE", "Attempt to assemble the reads in the specified file, useful for re-assembly [default: off]") do |arg|
-    options[:already_patterned_reads] = arg
-  end
-  opts.on("--output-assembly PATH", "Output assembly intermediate files to this directory [default: off]") do |arg|
-    options[:output_assembly_path] = arg
-  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("--output-begin-kmers PATH", "Output kmers found at the beginning point to this file [default: off]") do |arg|
-#    options[:output_begin_kmers] = arg
-#  end
-#  opts.on("--output-end-kmers PATH", "Output kmers found at the ending point to this file [default: off]") do |arg|
-#    options[:output_end_kmers] = arg
-#  end
-  opts.on("--assembly-coverage-cutoff NUMBER", "Require this much coverage in each node, all other nodes are removed [default: #{options[:assembly_coverage_cutoff]}]") do |arg|
-    options[:assembly_coverage_cutoff] = arg.to_f
-  end
-  opts.on("--contig-end-length LENGTH", "Number of base pairs to start into the ends of the contigs [default: #{options[:contig_end_length]}]") do |arg|
-    options[:contig_end_length] = arg.to_i
-  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[:upper_threshold].nil? or options[:lower_threshold].nil? or options[:pattern].nil? or options[:kmer_multiple_abundance_file].nil? or options[:reads_files].nil?
-  pp options
-  $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'
-
-pooled_reads_filename = 'pooled_sampled_reads.fasta'
-if options[:already_patterned_reads] #If skipping read extraction
-  pooled_reads_filename = options[:already_patterned_reads]
-
-else
-  # Parse pattern from cmdline
-  desired_pattern = KmerAbundancePattern.new
-  desired_pattern.parse_from_human(options[:pattern])
-  if options[:reads_files].length != desired_pattern.length
-    raise "Number of entries in the pattern #{desired_pattern.length} and number of reads files #{options[:reads].length} not equivalent!"
-  end
-
-  # Collect the kmers that will be used to find trusted reads i.e.
-  # Go through each line of the kmer abundance file, looking for kmers that suit the pattern
-  input_file = File.open options[:kmer_multiple_abundance_file]
-  csv = CSV.new(input_file, :col_sep => ' ')
-
-  whitelist_kmers = []
-  blacklist_kmers = []
-  csv.each do |row|
-    max_i = row.length - 2 if max_i.nil?
-
-    kmer = row[0]
-    counts = row[1...row.length].collect{|s| s.to_i}
-probe = 'TTACATCTTATCTACAATAAACCTTCTGCCTTAGTTTTAGAGCCTATCCGAAAAGTCCTGCTGCTCTGAATGTTATCCAAGCACATGCAAAATGAATTAGT'
-    this_pattern = []
-    counts.each_with_index do |count, i|
-      if count > options[:upper_threshold]
-        this_pattern[i] = true
-      elsif count < options[:lower_threshold]
-        this_pattern[i] = false
-      else
-        # coverage was in no man's land between thresholds.
-        # Ignore this kmer as noise.
-        this_pattern[i] = '-'
-      end
-    end
-    #log.debug "Found pattern #{this_pattern} from kmer #{kmer}, which has abundances #{counts}" if log.debug?
-
-    if desired_pattern.consistent_with? this_pattern
-      whitelist_kmers.push row[0]
-    else
-      # kmer is not present when it should be
-      blacklist_kmers.push row[0]
-    end
-  end
-  log.info "After parsing the kmer multiple abundance file, found #{whitelist_kmers.length} kmers that matched the pattern, and #{blacklist_kmers.length} that didn't"
-  unless whitelist_kmers.length > 0
-    log.error "No kmers found that satisfy the given pattern, exiting.."
-    exit 1
-  end
-
-
-  #outdir = options[:output_directory]
-  #Dir.mkdir outdir unless Dir.exist?(outdir)
-
-  # grep the pattern out from the raw reads, subsampling so as to not overwhelm the assembler
-  #Tempfile.open('whitelist') do |white|
-  File.open 'whitelist', 'w' do |white|
-    white.puts whitelist_kmers.join("\n")
-    white.close
-
-    #Tempfile.open('blacklist') do |black|
-    File.open('black','w') do |black|
-      black.puts blacklist_kmers.join("\n")
-      black.close
-
-      threadpool = []
-      sampled_read_files = []
-      log.info "Extracting reads that contain suitable kmers"
-      options[:reads_files].each_with_index do |file, i|
-        next unless desired_pattern[i] #Don't extract reads from reads where those reads should not have been amplified
-
-        sampled = File.basename(file)+'.sampled_reads.fasta'
-        sampled_read_files.push sampled
-
-        grep_path = "#{ENV['HOME']}/git/priner/bin/read_selection_by_kmer "
-        if options[:min_leftover_length]
-          grep_path += "--min-leftover-length #{options[:min_leftover_length]} "
-        end
-        thr = Thread.new do
-          grep_cmd = "#{grep_path} --whitelist #{white.path} --blacklist #{black.path} --reads #{file} --kmer-coverage-target #{options[:kmer_coverage_target]} > #{sampled}"
-          log.debug "Running cmd: #{grep_cmd}"
-          status, stdout, stderr = systemu grep_cmd
-          log.debug stderr
-
-          raise unless status.exitstatus == 0
-          log.debug "Finished extracting reads from #{file}"
-        end
-        threadpool.push thr
-      end
-      threadpool.each do |thread| thread.join; end #wait until everything is finito
-
-      log.info "Finished extracting reads for sampling. Now pooling sampled reads"
-      pool_cmd = "cat #{sampled_read_files.join ' '} >#{pooled_reads_filename}"
-      log.debug "Running cmd: #{pool_cmd}"
-      status, stdout, stderr = systemu pool_cmd
-      raise stderr if stderr != ''
-      raise unless status.exitstatus == 0
-    end
-  end
-end
-
-log.info "Extracting dummy reads from the ends of contigs to use as anchors"
-start_contig = options[:start_contig]
-end_contig = options[:end_contig]
-if [start_contig.length, end_contig.length].min < 2*options[:contig_end_length]
-  log.warn "Choice of initial/terminal nodes to perform graph search with may not be optimal due to the small contig size"
-end
-if [start_contig.length, end_contig.length].min < options[:contig_end_length]
-  log.error "At least one contig too small to proceed with current code base, need to fix the code to allow such a small contig"
-  exit 1
-end
-# Use the last bit of the first contig and the first bit of the second contig as the anchors
-velvet_result = nil
-Tempfile.open('anchors.fa') do |tempfile|
-  # Putting these same sequences in many times seems to better the
-  # chances velvet won't throw them out
-  50.times do
-    tempfile.puts ">start_contig"
-    tempfile.puts start_contig[start_contig.length-options[:contig_end_length]...start_contig.length]
-    tempfile.puts ">end_contig"
-    #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(end_contig[0...options[:contig_end_length]])
-    tempfile.puts fwd2.reverse_complement.to_s
-  end
-  tempfile.close
-  #puts `cat #{tempfile.path}`
-
-  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 and 2, respectively.
-  velvet_result = Bio::Velvet::Runner.new.velvet(
-    options[:velvet_kmer_size],
-    "-short #{tempfile.path} -short2 #{pooled_reads_filename}",
-    "-cov_cutoff #{options[:assembly_coverage_cutoff]} -read_trkg yes",
-    :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
-
-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[: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
-
-finder = Bio::AssemblyGraphAlgorithms::NodeFinder.new
-log.info "Finding node representing the end of the first contig"
-start_node, start_node_forward = finder.find_unique_node_with_sequence_id(graph, 1)
-log.info "Finding node representing the start of the second contig"
-end_node, end_node_forward = finder.find_unique_node_with_sequence_id(graph, 2)#TODO: find the node nearest the end of this, not the start
-if start_node.nil? or end_node.nil?
-  if start_node.nil?
-    log.error "Unable to find any nodes in the graph that have kmers corresponding to the _start_ point in them, sorry. Maybe fix the node finding code?"
-  end
-  if end_node.nil?
-    log.error "Unable to find any nodes in the graph that have kmers corresponding to the _end_ point in them, sorry. Maybe fix the node finding code?"
-  end
-
-  if options[:output_graph_png] or options[:output_graph_svg] or options[:output_graph_dot]
-    log.info "Converting assembly to a graphviz PNG/SVG/DOT, even if start/end node was not be found properly"
-    viser = Bio::Assembly::ABVisualiser.new
-    gv = viser.graphviz(graph)
-    if options[:output_graph_png]
-      log.info "Writing PNG of graph to #{options[:output_graph_png]}"
-      gv.output :png => options[:output_graph_png]
-    end
-    if options[:output_graph_svg]
-      log.info "Writing SVG of graph to #{options[:output_graph_svg]}"
-      gv.output :svg => options[:output_graph_svg]
-    end
-    if options[:output_graph_dot]
-      log.info "Writing DOT of graph to #{options[:output_graph_dot]}"
-      gv.output :dot => options[:output_graph_dot]
-    end
-  end
-  log.error "Unknown start or end points, giving up, sorry."
-  exit 1
-end
-log.info "Node(s) found that are suitable as initial and terminal nodes in the graph search, respectively: #{start_node.node_id} and #{end_node.node_id}"
-
-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})
-  gv.output :dot => options[:output_graph_dot]
-end
-
-log.info "Searching for trails between the initial and terminal nodes, within the assembly graph"
-cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
-#raise "Untested connection finder below"
-#trails = cartographer.find_all_trails_between_nodes(graph, start_node, end_node, options[:graph_search_leash_length], start_node_forward)
-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) between the initial and terminal nodes"
-
-log.info "Reading kmer abundances from #{options[:kmer_multiple_abundance_file]}.."
-kmer_hash = Bio::KmerMultipleAbundanceHash.parse_from_file options[:kmer_multiple_abundance_file]
-log.info "Finished reading the kmer abundances"
-
-if options[:trail_kmer_coverage_file]
-  log.info "Writing out kmer coverages to #{options[:trail_kmer_coverage_file]}.."
-  writer = Bio::AssemblyGraphAlgorithms::KmerCoverageWriter.new
-  io = File.open(options[:trail_kmer_coverage_file],'w')
-  writer.write(io, trails, kmer_hash)
-  log.info "Finished writing"
-end
-
-log.info "Filtering trail(s) based on kmer coverage, requiring each kmer in the path to have a minimum of #{options[:kmer_path_filter_min_coverage]} coverage in patterned reads, except for the #{options[:kmer_path_end_exclusion_length]}bp at the ends"
-kmer_path_filter = Bio::AssemblyGraphAlgorithms::KmerCoverageBasedPathFilter.new
-thresholds = desired_pattern.collect{|c| c == true ? 1 : 0}
-log.info "Using thresholds for filtering: #{thresholds}"
-trails = kmer_path_filter.filter(trails, kmer_hash, thresholds, :exclude_ending_length => options[:kmer_path_end_exclusion_length])
-log.info "After filtering remained #{trails.length} trails"
-
-log.debug "Found trails: #{trails.collect{|t| t.to_s}.join("\n")}"
-
-trails.each_with_index do |trail, i|
-  puts ">trail#{i+1}"
-  puts trail.sequence
-end