bio-velvet 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 798289b36dd93bb47a40f8f5c1e71ecf59305699
+  data.tar.gz: 3b97653d1ca5fd6b62c1ab1f097c3ffe868ce04c
+SHA512:
+  metadata.gz: ee227d4e19f9ce09edb22316aea8fa05fde499e27dcec8af4bec6afc7c8bbb7567b081f86cd64d0c34a00ec4d7e7c2202a3336914770ee00e053bf09907cf8f0
+  data.tar.gz: f84054f0cff8d627a57d2431d3af35b19a9941d65da10aee04e38431e436bc28ddef4021904df445d31d59a87cddabe8b61dcc409abd6df1db19bc9f41930fb2

data/.document

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+#  - 1.8.7
+#  - jruby-18mode # JRuby in 1.8 mode
+#  - rbx-18mode
+
+# uncomment this line if your project needs to run something other than `rake`:
+script: bundle exec rspec spec/bio-velvet_graph_spec.rb

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+gem 'bio-logger', '>=1.0.1'
+gem 'systemu'
+gem 'files'
+gem 'hopcsv', '>= 0.4.3'
+
+# 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 "rdoc", ">= 3.12"
+  gem "jeweler", ">= 1.8.4"
+  gem "bundler", ">= 1.0.21"
+  gem "bio", ">= 1.4.2"
+  gem "rdoc", ">= 3.12"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 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,62 @@
+# bio-velvet
+
+[![Build Status](https://secure.travis-ci.org/wwood/bioruby-velvet.png)](http://travis-ci.org/wwood/bioruby-velvet)
+
+```bio-velvet``` is a [biogem](biogems.info) for interacting with the [velvet](http://www.ebi.ac.uk/~zerbino/velvet/) sequence assembler. It includes both a wrapper for the velvet executable, as well as a a parser for the 'LastGraph' format files that velvet creates. This gives access to the underlying assembly graph created by velvet.
+
+## Installation
+To install ```bio-velvet``` and its rubygem dependencies:
+
+```sh
+gem install bio-velvet
+```
+
+## Usage
+
+To run velvet with a kmer length of 87 on a set of single ended reads in ```/path/to/reads.fa```:
+```ruby
+require 'bio-velvet'
+
+velvet_result = Bio::Velvet::Runner.new.velvet(87, '-short /path/to/reads.fa') #=> Bio::Velvet::Result object
+
+contigs_file = velvet_result.contigs_path #=> path to contigs file as a String
+lastgraph_file = velvet_result.last_graph_path #=> path to last graph file as a String
+```
+
+The graph file can be then parsed from the ```velvet_result```:
+```ruby
+graph = velvet_result.last_graph #=> Bio::Velvet::Graph object
+```
+In my experience (mostly on complex metagenomes), the graph object itself does not take as much RAM as I initially expected. Most of the hard work has already been done by velvet itself, particularly if the ```-cov_cutoff``` has been set. However parsing in the graph can take many minutes if the LastGraph file is big (>500MB).
+
+With this graph you can access interact with the graph e.g.
+```ruby
+graph.kmer_length #=> 87
+graph.nodes #=> Bio::Velvet::Graph::NodeArray object
+graph.nodes[3] #=> Bio::Velvet::Graph::Node object with node ID 3
+graph.get_arcs_by_node_id(1, 3) #=> an array of arcs between nodes 1 and 3 (Bio::Velvet::Graph::Arc objects)
+graph.nodes[5].noded_reads #=> array of Bio::Velvet::Graph::NodedRead objects, for read tracking
+```
+There is much more that can be done to interact with the graph object and its components - see the [rubydoc](http://rubydoc.info/gems/bio-velvet).
+
+## Project home page
+
+Information on the source tree, documentation, examples, issues and
+how to contribute, see
+
+  http://github.com/wwood/bioruby-velvet
+
+The BioRuby community is on IRC server: irc.freenode.org, channel: #bioruby.
+
+## Cite
+
+This code is currently unpublished.
+
+## Biogems.info
+
+This Biogem is published at (http://biogems.info/index.html#bio-velvet)
+
+## Copyright
+
+Copyright (c) 2013 Ben J Woodcroft. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# 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 = "bio-velvet"
+  gem.homepage = "http://github.com/wwood/bioruby-velvet"
+  gem.license = "MIT"
+  gem.summary = %Q{Parser to work with file formats used in the velvet DNA assembler}
+  gem.description = %Q{Parser to work with some file formats used in the velvet DNA assembler}
+  gem.email = "donttrustben@gmail.com"
+  gem.authors = ["Ben J Woodcroft"]
+  # dependencies defined in Gemfile
+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 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bio-velvet #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

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

data/lib/bio-velvet.rb

@@ -0,0 +1,13 @@
+require 'bio'
+require 'bio-logger'
+Bio::Log::LoggerPlus.new('bio-velvet')
+module Bio::Velvet
+  module Logging
+    def log
+      Bio::Log::LoggerPlus['bio-velvet']
+    end
+  end
+end
+
+require 'bio-velvet/graph'
+require 'bio-velvet/runner'

data/lib/bio-velvet/graph.rb

@@ -0,0 +1,517 @@
+require 'hopcsv'
+require 'bio'
+
+module Bio
+  module Velvet
+    class NotImplementedException < Exception; end
+
+    # Parser for a velvet assembler's graph file (Graph or LastGraph) output from velvetg
+    #
+    # The definition of this file is given in the velvet manual, at
+    # http://www.ebi.ac.uk/~zerbino/velvet/Manual.pdf
+    class Graph
+      include Bio::Velvet::Logging
+
+      # $NUMBER_OF_NODES $NUMBER_OF_SEQUENCES $HASH_LENGTH
+      attr_accessor :number_of_nodes, :number_of_sequences, :hash_length
+
+      # NodeArray object of all the graph's node objects
+      attr_accessor :nodes
+
+      # Array of Arc objects
+      attr_accessor :arcs
+
+      def self.log
+        self.new.log
+      end
+
+      # Parse a graph file from a Graph, Graph2 or LastGraph output file from velvet
+      # into a Bio::Velvet::Graph object
+      def self.parse_from_file(path_to_graph_file)
+        graph = self.new
+        state = :header
+
+        current_node = nil
+        graph.nodes = NodeArray.new
+        graph.arcs = ArcArray.new
+        current_node_direction = nil
+
+        line_number = 0
+        Hopcsv.foreach(path_to_graph_file,"\t") do |row|
+          line_number += 1
+
+          if state == :header
+            raise "parse exception on header line, this line #{line_number}: #{row.inspect}" unless row.length >= 3
+            graph.number_of_nodes = row[0].to_i
+            graph.number_of_sequences = row[1].to_i
+            graph.hash_length = row[2].to_i
+            #Not quite sure what the function of the 4th column is
+            state = :nodes_0
+            log.debug "Now parsing velvet graph nodes" if log.debug?
+            next
+          end
+
+          if state == :nodes_0
+            # NODE $NODE_ID $COV_SHORT1 $O_COV_SHORT1 $COV_SHORT2 $O_COV_SHORT2
+            # $ENDS_OF_KMERS_OF_NODE
+            # $ENDS_OF_KMERS_OF_TWIN_NODE
+            if row[0] == 'NODE'
+              raise unless row.length > 2
+              current_node = Node.new
+              current_node.node_id = row[1].to_i
+              current_node.length = row[2].to_i
+              current_node.coverages = row[3...row.length].collect{|c| c.to_i}
+              current_node.parent_graph = graph
+              state = :nodes_1
+              raise "Duplicate node name" unless graph.nodes[current_node.node_id].nil?
+              graph.nodes[current_node.node_id] = current_node
+              next
+            else
+              state = :arc
+              log.debug "Now parsing velvet graph arcs" if log.debug?
+              # No next in the loop so that this line gets parsed as an ARC further down the loop
+            end
+          elsif state == :nodes_1
+            # Sometimes nodes can be empty
+            row[0] ||= ''
+            current_node.ends_of_kmers_of_node = row[0]
+            raise "Unexpected nodes_1 type line on line #{line_number}: #{row.inspect}" if row.length != 1
+            state = :nodes_2
+            next
+          elsif state == :nodes_2
+            # Sometimes nodes can be empty
+            row[0] ||= ''
+            raise if row.length != 1
+            current_node.ends_of_kmers_of_twin_node = row[0]
+            state = :nodes_0
+            next
+          end
+
+          if state == :arc
+            if row[0] == 'ARC'
+              # ARC $START_NODE $END_NODE $MULTIPLICITY
+              arc = Arc.new
+              raise unless row.length == 4
+              arc.begin_node_id = row[1].to_i.abs
+              arc.end_node_id = row[2].to_i.abs
+              arc.multiplicity = row[3].to_i
+              arc.begin_node_direction = (row[1].to_i > 0)
+              arc.end_node_direction = (row[2].to_i > 0)
+              graph.arcs.push arc
+              next
+            else
+              state = :nr
+              log.debug "Finished parsing velvet graph arcs. Now parsing the rest of the file" if log.debug?
+            end
+          end
+
+          if state == :nr
+            if row[0] == 'SEQ'
+              log.warn "velvet graph parse warning: SEQ lines in the Graph file parsing not implemented yet, tracking of reads now not parsed either"
+              break
+            end
+
+            # If short reads are tracked, for every node a block of read identifiers:
+            # NR $NODE_ID $NUMBER_OF_SHORT_READS
+            # $READ_ID $OFFSET_FROM_START_OF_NODE $START_COORD
+            # $READ_ID2 etc.
+            #p row
+            if row[0] == 'NR'
+              raise unless row.length == 3
+              node_pm = row[1].to_i
+              current_node_direction = node_pm > 0
+              current_node = graph.nodes[node_pm.abs]
+              current_node.number_of_short_reads ||= 0
+              current_node.number_of_short_reads += row[2].to_i
+              next
+            else
+              raise unless row.length == 3
+              nr = NodedRead.new
+              nr.read_id = row[0].to_i
+              nr.offset_from_start_of_node = row[1].to_i
+              nr.start_coord = row[2].to_i
+              nr.direction = current_node_direction
+              current_node.short_reads ||= []
+              current_node.short_reads.push nr
+              next
+            end
+          end
+        end
+        log.debug "Finished parsing velvet graph file" if log.debug?
+
+        return graph
+      end
+
+      # Return an array of Arc objects between two nodes (specified by integer IDs),
+      # or an empty array if none exists. There is four possible arcs between
+      # two nodes, connecting their beginnings and ends
+      def get_arcs_by_node_id(node_id1, node_id2)
+        @arcs.get_arcs_by_node_id(node_id1, node_id2)
+      end
+
+      # Return an array of Arc objects between two nodes (specified by node objects),
+      # or an empty array if none exists. There is four possible arcs between
+      # two nodes, connecting their beginnings and ends
+      def get_arcs_by_node(node1, node2)
+        @arcs.get_arcs_by_node_id(node1.node_id, node2.node_id)
+      end
+
+      # Return the adjacent nodes in the graph that connect to the end of a node
+      def neighbours_off_end(node)
+        # Find all arcs that include this node in the right place
+        passable_nodes = []
+        @arcs.get_arcs_by_node_id(node.node_id).each do |arc|
+          if arc.begin_node_id == node.node_id and arc.begin_node_direction
+            # The most intuitive case
+            passable_nodes.push nodes[arc.end_node_id]
+          elsif arc.end_node_id == node.node_id and !arc.end_node_direction
+            passable_nodes.push nodes[arc.begin_node_id]
+          end
+        end
+        return passable_nodes
+      end
+
+      # Return the adjacent nodes in the graph that connect to the end of a node
+      def neighbours_into_start(node)
+        # Find all arcs that include this node in the right place
+        passable_nodes = []
+        @arcs.get_arcs_by_node_id(node.node_id).each do |arc|
+          if arc.end_node_id == node.node_id and arc.end_node_direction
+            passable_nodes.push nodes[arc.begin_node_id]
+          elsif arc.begin_node_id == node.node_id and !arc.begin_node_direction
+            passable_nodes.push nodes[arc.end_node_id]
+          end
+        end
+        return passable_nodes
+      end
+
+
+      # Deletes nodes and associated arcs from the graph if the block passed
+      # evaluates to true (as in Array#delete_if). Actually the associated arcs
+      # are deleted first, and then the node, so that the graph remains sane at all
+      # times - there is never dangling arcs, as such.
+      #
+      # Returns a [deleted_nodes, deleted_arc] tuple, which are both enumerables,
+      # each in no particular order.
+      def delete_nodes_if(&block)
+        deleted_nodes = []
+        deleted_arcs = []
+        nodes.each do |node|
+          if yield(node)
+            deleted_nodes.push node
+
+            # delete associated arcs
+            arcs_to_del = @arcs.get_arcs_by_node_id(node.node_id)
+            deleted_arcs.push arcs_to_del
+            arcs_to_del.each do |arc|
+              @arcs.delete arc
+            end
+
+            # delete the arc itself
+            nodes.delete node
+          end
+        end
+        return deleted_nodes, deleted_arcs.flatten
+      end
+
+
+
+
+
+      # A container class for a list of Node objects. Can index with 1-offset
+      # IDs, so that they line up with the identifiers in velvet Graph files,
+      # yet respond sensibly to NodeArray#length, etc.
+      class NodeArray
+        include Enumerable
+
+        def initialize
+          # Internal index is required because when things get deleted stuff changes.
+          @internal_structure = {}
+        end
+
+        def []=(node_id, value)
+          @internal_structure[node_id] = value
+        end
+
+        def [](node_id)
+          @internal_structure[node_id]
+        end
+
+        def delete(node)
+          @internal_structure.delete node.node_id
+        end
+
+        def length
+          @internal_structure.length
+        end
+
+        def each(&block)
+          @internal_structure.each do |internal_id, node|
+            block.yield node
+          end
+        end
+      end
+
+      class ArcArray
+        include Enumerable
+
+        def initialize
+          # Internal structure is hash of [node_id1, node_id2] => Array of arcs
+          @internal_structure = {}
+          @node_to_keys = {}
+        end
+
+        def push(arc)
+          key = [arc.begin_node_id, arc.end_node_id].sort
+          @internal_structure[key] ||= []
+          @internal_structure[key].push arc
+          @node_to_keys[arc.begin_node_id] ||= []
+          @node_to_keys[arc.begin_node_id].push key
+          unless arc.begin_node_id == arc.end_node_id
+            @node_to_keys[arc.end_node_id] ||= []
+            @node_to_keys[arc.end_node_id].push key
+          end
+        end
+
+        # Return all arcs into or out of the given node_id, or
+        def get_arcs_by_node_id(node_id1, node_id2=nil)
+          if node_id2.nil?
+            next_keys = @node_to_keys[node_id1]
+            return [] if next_keys.nil?
+            next_keys.uniq.collect do |key|
+              @internal_structure[key]
+            end.flatten
+          else
+            to_return = @internal_structure[[node_id1, node_id2].sort]
+            if to_return.nil?
+              return []
+            else
+              return to_return
+            end
+          end
+        end
+
+        def delete(arc)
+          key = [arc.begin_node_id, arc.end_node_id].sort
+          @internal_structure[key].delete arc
+          # If there is no other arcs with this same key, clean up more
+          if @internal_structure[key].empty?
+            @internal_structure.delete key
+            @node_to_keys[key[0]].delete key
+            @node_to_keys[key[1]].delete key
+            @node_to_keys[key[0]] = nil if @node_to_keys[key[0]].nil? or @node_to_keys[key[0]].empty?
+            @node_to_keys[key[1]] = nil if @node_to_keys[key[1]].nil? or @node_to_keys[key[1]].empty?
+          end
+        end
+
+        def length
+          @internal_structure.values.flatten.length
+        end
+
+        def each(&block)
+          @internal_structure.each do |internal_id, arcs|
+            arcs.each do |arc|
+              block.yield arc
+            end
+          end
+        end
+      end
+
+      class Node
+        include Bio::Velvet::Logging
+
+        attr_accessor :node_id, :coverages, :ends_of_kmers_of_node, :ends_of_kmers_of_twin_node
+
+        # For read tracking
+        attr_accessor :number_of_short_reads
+        # For read tracking - an array of NodedRead objects
+        attr_accessor :short_reads
+
+        # Graph to which this node belongs
+        attr_accessor :parent_graph
+
+        # Number of nucleotides in this node if a contig was made from this contig alone
+        attr_accessor :length
+
+        # The sequence of this node, should a contig be made solely out of this node.
+        # The kmer length is that kmer length that was used to create the assembly.
+        #
+        # If this node has a sequence that is 2 or more less than the hash length, then the
+        # sequence of this node requires information outside of this object, and gathering
+        # that information is not implemented here.
+        def sequence
+          if !sequence?
+            raise NotImplementedException, "Attempted to get the sequence of a velvet node that is too short, such that the sequence info is not fully present in the node object"
+          end
+          kmer_length = @parent_graph.hash_length
+
+           # Sequence is the reverse complement of the ends_of_kmers_of_twin_node,
+           # Then the ends_of_kmers_of_node after removing the first kmer_length - 1
+           # nucleotides
+           length_to_get_from_fwd = corresponding_contig_length - @ends_of_kmers_of_twin_node.length
+           fwd_length = @ends_of_kmers_of_node.length
+           raise "Programming error" if length_to_get_from_fwd > fwd_length
+           revcom(@ends_of_kmers_of_twin_node)+
+             @ends_of_kmers_of_node[-length_to_get_from_fwd...fwd_length]
+        end
+
+        # Number of nucleotides in this node if this contig length is being added to
+        # another node's length (nodes overlap)
+        def length_alone
+          @ends_of_kmers_of_node.length
+        end
+
+        # The common length of [ends_of_kmers_of_node and :ends_of_kmers_of_twin_node]
+        # is equal to the length of the corresponding contig minus k − 1.
+        #
+        # This method returns that corresponding contig's length
+        def corresponding_contig_length
+          @ends_of_kmers_of_node.length+@parent_graph.hash_length-1
+        end
+
+        # Is it possible to extract the sequence of this node? I.e. is it long enough?
+        def sequence?
+          kmer_length = @parent_graph.hash_length
+          if kmer_length -1 > @ends_of_kmers_of_node.length
+            return false
+          else
+            return true
+          end
+        end
+
+        # The reverse complement of this node's sequence
+        def reverse_sequence
+          revcom(sequence)
+        end
+
+        # Number of nucleotides in this node if this contig length is being added to
+        # another node's length (nodes overlap)
+        def length_alone
+          @ends_of_kmers_of_node.length
+        end
+
+        def to_s
+          "Node #{@node_id}: #{@ends_of_kmers_of_node} / #{@ends_of_kmers_of_twin_node}"
+        end
+
+        def inspect
+          to_s
+        end
+
+        # Return the sum of all coverage columns, divided by the length of the node,
+        # or nil if this node has no coverage
+        def coverage
+          return nil if length == 0
+
+          coverage = 0
+          coverages.each_with_index do |cov, i|
+            # Only take the 0th, 2nd, 4th, etc, don't want the O_cov things
+            coverage += cov if i.modulo(2) == 0
+          end
+          return coverage.to_f / length
+        end
+
+        private
+        def revcom(seq)
+          Bio::Sequence::NA.new(seq).reverse_complement.to_s.upcase
+        end
+      end
+
+      class Arc
+        attr_accessor :begin_node_id, :end_node_id, :multiplicity
+
+        # true for forwards direction, false for reverse
+        attr_accessor :begin_node_direction, :end_node_direction
+
+        def directions_opposing?
+          if (@begin_node_direction == true and @end_node_direction == false) or
+            (@begin_node_direction == false and @end_node_direction == true)
+            return true
+          elsif [true,false].include?(@begin_node_direction) and [true,false].include?(@end_node_direction)
+            return false
+          else
+            raise Exception, "Node directions not set! Cannot tell whether directions are opposing"
+          end
+        end
+
+        def begin_node_forward?
+          @begin_node_direction
+        end
+
+        def end_node_forward?
+          @end_node_forward
+        end
+
+        # Returns true if this arc connects the end of the first node
+        # to the start of the second node, else false
+        def connects_end_to_beginning?(first_node_id, second_node_id)
+          # ARC $START_NODE $END_NODE $MULTIPLICITY
+          #Note: this one line implicitly represents an arc from node A to B and
+          #another, with same multiplicity, from -B to -A.
+          (first_node_id == @begin_node_id and second_node_id == @end_node_id and
+            @begin_node_direction == true and @end_node_direction == true) or
+            (first_node_id == @end_node_id and second_node_id = @begin_node_id and
+            @begin_node_direction == false and @end_node_direction == false)
+        end
+
+        # Returns true if this arc connects the end of the first node
+        # to the end of the second node, else false
+        def connects_end_to_end?(first_node_id, second_node_id)
+          (first_node_id == @begin_node_id and second_node_id == @end_node_id and
+            @begin_node_direction == true and @end_node_direction == false) or
+            (first_node_id == @end_node_id and second_node_id = @begin_node_id and
+            @begin_node_direction == true and @end_node_direction == false)
+        end
+
+        # Returns true if this arc connects the start of the first node
+        # to the start of the second node, else false
+        def connects_beginning_to_beginning?(first_node_id, second_node_id)
+          (first_node_id == @begin_node_id and second_node_id == @end_node_id and
+            @begin_node_direction == false and @end_node_direction == true) or
+            (first_node_id == @end_node_id and second_node_id = @begin_node_id and
+            @begin_node_direction == false and @end_node_direction == true)
+        end
+
+        # Returns true if this arc connects the start of the first node
+        # to the start of the second node, else false
+        def connects_beginning_to_end?(first_node_id, second_node_id)
+          (first_node_id == @begin_node_id and second_node_id == @end_node_id and
+            @begin_node_direction == false and @end_node_direction == false) or
+            (first_node_id == @end_node_id and second_node_id = @begin_node_id and
+            @begin_node_direction == true and @end_node_direction == true)
+        end
+
+        # Return true if this arc connects the beginning of the node,
+        # else false
+        def connects_to_beginning?(node_id)
+          (node_id == @begin_node_id and !@begin_node_direction) or
+          (node_id == @end_node_id and @end_node_direction)
+        end
+
+        # Return true if this arc connects the end of the node,
+        # else false
+        def connects_to_end?(node_id)
+          (node_id == @begin_node_id and @begin_node_direction) or
+          (node_id == @end_node_id and !@end_node_direction)
+        end
+
+        def to_s
+          str = ''
+          str += '-' if @begin_node_direction == false
+          str += @begin_node_id.to_s
+          str += ' '
+          str += '-' if @end_node_direction == false
+          str += @end_node_id.to_s
+          str += ' '
+          str += @multiplicity.to_s
+          str
+        end
+      end
+
+      # Tracked read, part of a node
+      class NodedRead
+        attr_accessor :read_id, :offset_from_start_of_node, :start_coord, :direction
+      end
+    end
+  end
+end