macroape 4.0.2 → 4.1.0

data/lib/macroape/cli/align_motifs.rb

@@ -1,100 +1,120 @@
-require_relative '../../macroape'
-require 'shellwords'
-
-module Macroape
-  module CLI
-    module AlignMotifs
-
-      def self.main(argv)
-        doc = <<-EOS.strip_doc
-          Align motifs tool.
-          It takes motifs and builds alignment of each motif to the first (leader) motif.
-
-          Output has format:
-            pwm_file_1  shift_1  orientation_1
-            pwm_file_2  shift_2  orientation_2
-            pwm_file_3  shift_3  orientation_3
-
-          Usage:
-            #{run_tool_cmd} [options] <leader pm> <rest pm files>...
-              or
-            ls rest_pms/*.pm | #{run_tool_cmd} [options]
-              or
-            ls rest_pms/*.pm | #{run_tool_cmd} [options] <leader pm>
-
-          Options:
-            [-p <P-value>]
-            [-d <discretization level>]
-            [--pcm] - treat the input file as Position Count Matrix. PCM-to-PWM transformation to be done internally.
-            [--boundary lower|upper] Upper boundary (default) means that the obtained P-value is greater than or equal to the requested P-value
-            [-b <background probabilities] ACGT - 4 numbers, comma-delimited(spaces not allowed), sum should be equal to 1, like 0.25,0.24,0.26,0.25
-        EOS
-
-        if (argv.empty? && $stdin.tty?) || ['-h', '--h', '-help', '--help'].any?{|help_option| argv.include?(help_option)}
-          $stderr.puts doc
-          exit
-        end
-
-        leader_background = [1,1,1,1]
-        rest_motifs_background = [1,1,1,1]
-        discretization = 1
-        pvalue = 0.0005
-        max_hash_size = 10000000
-        max_pair_hash_size = 10000
-        pvalue_boundary = :upper
-
-        data_model = argv.delete('--pcm') ? Bioinform::PCM : Bioinform::PWM
-
-        while argv.first && argv.first.start_with?('-')
-          case argv.shift
-            when '-p'
-              pvalue = argv.shift.to_f
-            when '-d'
-              discretization = argv.shift.to_f
-            when '--max-hash-size'
-              max_hash_size = argv.shift.to_i
-            when '--max-2d-hash-size'
-              max_pair_hash_size = argv.shift.to_i
-            when '-b'
-              rest_motifs_background = leader_background = argv.shift.split(',').map(&:to_f)
-            when '-b1'
-              leader_background = argv.shift.split(',').map(&:to_f)
-            when '-b2'
-              rest_motifs_background = argv.shift.split(',').map(&:to_f)
-            when '--boundary'
-              pvalue_boundary = argv.shift.to_sym
-              raise 'boundary should be either lower or upper'  unless  pvalue_boundary == :lower || pvalue_boundary == :upper
-          end
-        end
-
-        pwm_files = argv
-        pwm_files += $stdin.read.shellsplit  unless $stdin.tty?
-        leader_pwm_file = pwm_files.first
-        rest_pwm_files = pwm_files[1..-1]
-        rest_pwm_files.reject!{|filename| File.expand_path(filename) == File.expand_path(leader_pwm_file)}
-
-        raise 'Specify leader file'  unless leader_pwm_file
-
-        shifts = []
-        shifts << [leader_pwm_file, 0, :direct]
-        pwm_first = data_model.new(File.read(leader_pwm_file)).set_parameters(background: leader_background).to_pwm
-        pwm_first.set_parameters(background: leader_background, max_hash_size: max_hash_size).discrete!(discretization)
-
-        rest_pwm_files.each do |motif_name|
-          pwm_second = data_model.new(File.read(motif_name)).set_parameters(background: rest_motifs_background).to_pwm
-          pwm_second.set_parameters(background: rest_motifs_background, max_hash_size: max_hash_size).discrete!(discretization)
-          cmp = Macroape::PWMCompare.new(pwm_first, pwm_second).set_parameters(max_pair_hash_size: max_pair_hash_size)
-          info = cmp.jaccard_by_pvalue(pvalue)
-          shifts << [motif_name, info[:shift], info[:orientation]]
-        end
-
-        shifts.each do |motif_name, shift,orientation|
-          puts "#{motif_name}\t#{shift}\t#{orientation}"
-        end
-      rescue => err
-        $stderr.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse --help option for help\n\n#{doc}"
-      end
-
-    end
-  end
-end
+require_relative '../../macroape'
+require 'shellwords'
+
+module Macroape
+  module CLI
+    module AlignMotifs
+
+      def self.main(argv)
+        doc = <<-EOS.strip_doc
+          Align motifs tool.
+          It takes motifs and builds alignment of each motif to the first (leader) motif.
+
+          Output has format:
+            pwm_file_1  shift_1  orientation_1
+            pwm_file_2  shift_2  orientation_2
+            pwm_file_3  shift_3  orientation_3
+
+          Usage:
+            #{run_tool_cmd} [options] <leader pm> <rest pm files>...
+              or
+            ls rest_pms/*.pm | #{run_tool_cmd} [options]
+              or
+            ls rest_pms/*.pm | #{run_tool_cmd} [options] <leader pm>
+
+          Options:
+            [-p <P-value>]
+            [-d <discretization level>]
+            [--pcm] - treat the input file as Position Count Matrix. PCM-to-PWM transformation to be done internally.
+            [--boundary lower|upper] Upper boundary (default) means that the obtained P-value is greater than or equal to the requested P-value
+            [-b <background probabilities] ACGT - 4 numbers, comma-delimited(spaces not allowed), sum should be equal to 1, like 0.25,0.24,0.26,0.25
+        EOS
+
+        if (argv.empty? && $stdin.tty?) || ['-h', '--h', '-help', '--help'].any?{|help_option| argv.include?(help_option)}
+          $stderr.puts doc
+          exit
+        end
+
+        leader_background = Bioinform::Background::Wordwise
+        rest_motifs_background = Bioinform::Background::Wordwise
+        discretization = 1
+        pvalue = 0.0005
+        max_hash_size = 10000000
+        max_pair_hash_size = 10000
+        pvalue_boundary = :upper
+
+        data_model = argv.delete('--pcm') ? :pcm : :pwm
+
+        while argv.first && argv.first.start_with?('-')
+          case argv.shift
+            when '-p'
+              pvalue = argv.shift.to_f
+            when '-d'
+              discretization = argv.shift.to_f
+            when '--max-hash-size'
+              max_hash_size = argv.shift.to_i
+            when '--max-2d-hash-size'
+              max_pair_hash_size = argv.shift.to_i
+            when '-b'
+              rest_motifs_background = leader_background = Bioinform::Background.from_string(argv.shift)
+            when '-b1'
+              leader_background = Bioinform::Background.from_string(argv.shift)
+            when '-b2'
+              rest_motifs_background = Bioinform::Background.from_string(argv.shift)
+            when '--boundary'
+              pvalue_boundary = argv.shift.to_sym
+              raise 'boundary should be either lower or upper'  unless  pvalue_boundary == :lower || pvalue_boundary == :upper
+          end
+        end
+
+        pwm_files = argv
+        pwm_files += $stdin.read.shellsplit  unless $stdin.tty?
+        leader_pwm_file = pwm_files.first
+        rest_pwm_files = pwm_files[1..-1]
+        rest_pwm_files.reject!{|filename| File.expand_path(filename) == File.expand_path(leader_pwm_file)}
+
+        raise 'Specify leader file'  unless leader_pwm_file
+
+        shifts = []
+        shifts << [leader_pwm_file, 0, :direct]
+
+        input_first = File.read(leader_pwm_file)
+        input_first = Bioinform::MatrixParser.new.parse!(input_first)
+        case data_model
+        when :pcm
+          pcm_first = Bioinform::MotifModel::PCM.new(input_first[:matrix]).named(input_first[:name])
+          pwm_first = Bioinform::ConversionAlgorithms::PCM2PWMConverter.new(pseudocount: :log, background: leader_background).convert(pcm_first)
+        when :pwm
+          pwm_first = Bioinform::MotifModel::PWM.new(input_first[:matrix]).named(input_first[:name])
+        end
+
+        pwm_first = pwm_first.discreted(discretization)
+        counting_first = PWMCounting.new(pwm_first, background: leader_background, max_hash_size: max_hash_size)
+
+        rest_pwm_files.each do |motif_name|
+          input_second = File.read(motif_name)
+          input_second = Bioinform::MatrixParser.new.parse!(input_second)
+          case data_model
+          when :pcm
+            pcm_second = Bioinform::MotifModel::PCM.new(input_second[:matrix]).named(input_second[:name])
+            pwm_second = Bioinform::ConversionAlgorithms::PCM2PWMConverter.new(pseudocount: :log, background: rest_motifs_background).convert(pcm_second)
+          when :pwm
+            pwm_second = Bioinform::MotifModel::PWM.new(input_second[:matrix]).named(input_second[:name])
+          end
+          pwm_second = pwm_second.discreted(discretization)
+          counting_second = PWMCounting.new(pwm_second, background: rest_motifs_background, max_hash_size: max_hash_size)
+          cmp = Macroape::PWMCompare.new(counting_first, counting_second).tap{|x| x.max_pair_hash_size = max_pair_hash_size }
+          info = cmp.jaccard_by_pvalue(pvalue)
+          shifts << [motif_name, info[:shift], info[:orientation]]
+        end
+
+        shifts.each do |motif_name, shift,orientation|
+          puts "#{motif_name}\t#{shift}\t#{orientation}"
+        end
+      rescue => err
+        $stderr.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse --help option for help\n\n#{doc}"
+      end
+
+    end
+  end
+end

data/lib/macroape/cli/eval_alignment.rb

@@ -1,156 +1,157 @@
-require_relative '../../macroape'
-
-module Macroape
-  module CLI
-    module EvalAlignment
-
-      def self.main(argv)
-        doc = <<-EOS.strip_doc
-          Command-line format:
-          #{run_tool_cmd} <1st matrix pat-file> <2nd matrix pat-file> <shift> <orientation(direct/revcomp)> [options]
-
-          Options:
-            [-p <P-value>]
-            [-d <discretization level>]
-            [--pcm] - treat the input file as Position Count Matrix. PCM-to-PWM transformation to be done internally.
-            [--boundary lower|upper] Upper boundary (default) means that the obtained P-value is greater than or equal to the requested P-value
-            [-b <background probabilities] ACGT - 4 numbers, comma-delimited(spaces not allowed), sum should be equal to 1, like 0.25,0.24,0.26,0.25
-            [--first-threshold <threshold for the first matrix>]
-            [--second-threshold <threshold for the second matrix>]
-
-          Examples:
-            #{run_tool_cmd} motifs/KLF4_f2.pat motifs/SP1_f1.pat -1 direct -p 0.0005 -d 100 -b 0.3,0.2,0.2,0.3
-            #{run_tool_cmd} motifs/KLF4_f2.pat motifs/SP1_f1.pat 3 revcomp
-        EOS
-
-        if argv.empty? || ['-h', '--h', '-help', '--help'].any?{|help_option| argv.include?(help_option)}
-          $stderr.puts doc
-          exit
-        end
-
-        pvalue = 0.0005
-        discretization = 10.0
-
-        first_background = [1,1,1,1]
-        second_background = [1,1,1,1]
-        max_hash_size = 10000000
-        max_pair_hash_size = 10000
-        pvalue_boundary = :upper
-
-        data_model = argv.delete('--pcm') ? Bioinform::PCM : Bioinform::PWM
-
-        first_file = argv.shift
-        second_file = argv.shift
-
-        shift = argv.shift
-        orientation = argv.shift
-
-        raise 'You should specify two input sources (each is filename or .stdin)'  unless first_file and second_file
-        raise 'You should specify shift' unless shift
-        raise 'You should specify orientation' unless orientation
-
-        shift = shift.to_i
-        orientation = orientation.to_sym
-
-        case orientation
-          when :direct
-            reverse = false
-          when :revcomp
-            reverse = true
-          else
-            raise 'Unknown orientation(direct/revcomp)'
-        end
-
-
-        until argv.empty?
-          case argv.shift
-            when '-p'
-              pvalue = argv.shift.to_f
-            when '-d'
-              discretization = argv.shift.to_f
-            when '--max-hash-size'
-              max_hash_size = argv.shift.to_i
-            when '--max-2d-hash-size'
-              max_pair_hash_size = argv.shift.to_i
-            when '-b'
-              second_background = first_background = argv.shift.split(',').map(&:to_f)
-            when '-b1'
-              first_background = argv.shift.split(',').map(&:to_f)
-            when '-b2'
-              second_background = argv.shift.split(',').map(&:to_f)
-            when '--boundary'
-              pvalue_boundary = argv.shift.to_sym
-              raise 'boundary should be either lower or upper'  unless  pvalue_boundary == :lower || pvalue_boundary == :upper
-            when '--first-threshold'
-              predefined_threshold_first = argv.shift.to_f
-            when '--second-threshold'
-              predefined_threshold_second = argv.shift.to_f
-          end
-        end
-        raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless first_background == first_background.reverse
-        raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless second_background == second_background.reverse
-
-        if first_file == '.stdin' || second_file == '.stdin'
-          input = $stdin.read
-          parser = data_model.choose_parser(input).new(input)
-        end
-
-        if first_file == '.stdin'
-          input_first = parser.parse
-        else
-          raise "Error! File #{first_file} don't exist" unless File.exist?(first_file)
-          input_first = File.read(first_file)
-        end
-        pwm_first = data_model.new(input_first).set_parameters(background: first_background).to_pwm
-
-        if second_file == '.stdin'
-          input_second = parser.parse
-        else
-          raise "Error! File #{second_file} don't exist" unless File.exist?(second_file)
-          input_second = File.read(second_file)
-        end
-        pwm_second = data_model.new(input_second).set_parameters(background: second_background).to_pwm
-
-        pwm_first.set_parameters(background: first_background, max_hash_size: max_hash_size).discrete!(discretization)
-        pwm_second.set_parameters(background: second_background, max_hash_size: max_hash_size).discrete!(discretization)
-
-        cmp = Macroape::PWMCompareAligned.new(pwm_first, pwm_second, shift, orientation).set_parameters(max_pair_hash_size: max_pair_hash_size)
-
-        if predefined_threshold_first
-          threshold_first = predefined_threshold_first * discretization
-        else
-          if pvalue_boundary == :lower
-            threshold_first = pwm_first.threshold(pvalue)
-          else
-            threshold_first = pwm_first.weak_threshold(pvalue)
-          end
-        end
-
-        if predefined_threshold_second
-          threshold_second = predefined_threshold_second * discretization
-        else
-          if pvalue_boundary == :lower
-            threshold_second = pwm_second.threshold(pvalue)
-          else
-            threshold_second = pwm_second.weak_threshold(pvalue)
-          end
-        end
-        info = cmp.alignment_infos.merge( cmp.jaccard(threshold_first, threshold_second) )
-        info.merge!(predefined_threshold_first: predefined_threshold_first,
-                    predefined_threshold_second: predefined_threshold_second,
-                    threshold_first: threshold_first / discretization,
-                    threshold_second: threshold_second / discretization,
-                    discretization: discretization,
-                    first_background: first_background,
-                    second_background: second_background,
-                    requested_pvalue: pvalue,
-                    pvalue_boundary: pvalue_boundary)
-        puts Helper.similarity_info_string(info)
-
-      rescue => err
-        $stderr.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse --help option for help\n\n#{doc}"
-      end
-
-    end
-  end
-end
+require_relative '../../macroape'
+
+module Macroape
+  module CLI
+    module EvalAlignment
+
+      def self.main(argv)
+        doc = <<-EOS.strip_doc
+          Command-line format:
+          #{run_tool_cmd} <1st matrix pat-file> <2nd matrix pat-file> <shift> <orientation(direct/revcomp)> [options]
+
+          Options:
+            [-p <P-value>]
+            [-d <discretization level>]
+            [--pcm] - treat the input file as Position Count Matrix. PCM-to-PWM transformation to be done internally.
+            [--boundary lower|upper] Upper boundary (default) means that the obtained P-value is greater than or equal to the requested P-value
+            [-b <background probabilities] ACGT - 4 numbers, comma-delimited(spaces not allowed), sum should be equal to 1, like 0.25,0.24,0.26,0.25
+            [--first-threshold <threshold for the first matrix>]
+            [--second-threshold <threshold for the second matrix>]
+
+          Examples:
+            #{run_tool_cmd} motifs/KLF4_f2.pat motifs/SP1_f1.pat -1 direct -p 0.0005 -d 100 -b 0.3,0.2,0.2,0.3
+            #{run_tool_cmd} motifs/KLF4_f2.pat motifs/SP1_f1.pat 3 revcomp
+        EOS
+
+        if argv.empty? || ['-h', '--h', '-help', '--help'].any?{|help_option| argv.include?(help_option)}
+          $stderr.puts doc
+          exit
+        end
+
+        pvalue = 0.0005
+        discretization = 10.0
+
+        first_background = Bioinform::Background::Wordwise
+        second_background = Bioinform::Background::Wordwise
+        max_hash_size = 10000000
+        max_pair_hash_size = 10000
+        pvalue_boundary = :upper
+
+        data_model = argv.delete('--pcm') ? :pcm : :pwm
+
+        first_file = argv.shift
+        second_file = argv.shift
+
+        shift = argv.shift
+        orientation = argv.shift
+
+        raise 'You should specify two input files'  unless first_file and second_file
+        raise 'You should specify shift' unless shift
+        raise 'You should specify orientation' unless orientation
+
+        shift = shift.to_i
+        orientation = orientation.to_sym
+
+        case orientation
+          when :direct
+            reverse = false
+          when :revcomp
+            reverse = true
+          else
+            raise 'Unknown orientation(direct/revcomp)'
+        end
+
+
+        until argv.empty?
+          case argv.shift
+            when '-p'
+              pvalue = argv.shift.to_f
+            when '-d'
+              discretization = argv.shift.to_f
+            when '--max-hash-size'
+              max_hash_size = argv.shift.to_i
+            when '--max-2d-hash-size'
+              max_pair_hash_size = argv.shift.to_i
+            when '-b'
+              second_background = first_background = Bioinform::Background.from_string(argv.shift)
+            when '-b1'
+              first_background = Bioinform::Background.from_string(argv.shift)
+            when '-b2'
+              second_background = Bioinform::Background.from_string(argv.shift)
+            when '--boundary'
+              pvalue_boundary = argv.shift.to_sym
+              raise 'boundary should be either lower or upper'  unless  pvalue_boundary == :lower || pvalue_boundary == :upper
+            when '--first-threshold'
+              predefined_threshold_first = argv.shift.to_f
+            when '--second-threshold'
+              predefined_threshold_second = argv.shift.to_f
+          end
+        end
+        raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless first_background.symmetric?
+        raise 'background should be symmetric: p(A)=p(T) and p(G) = p(C)' unless second_background.symmetric?
+
+        raise "Error! File #{first_file} don't exist" unless File.exist?(first_file)
+        input_first = File.read(first_file)
+        input_first = Bioinform::MatrixParser.new.parse!(input_first)
+
+        raise "Error! File #{second_file} don't exist" unless File.exist?(second_file)
+        input_second = File.read(second_file)
+        input_second = Bioinform::MatrixParser.new.parse!(input_second)
+
+        case data_model
+        when :pcm
+          pcm_first = Bioinform::MotifModel::PCM.new(input_first[:matrix]).named(input_first[:name])
+          pwm_first = Bioinform::ConversionAlgorithms::PCM2PWMConverter.new(pseudocount: :log, background: first_background).convert(pcm_first)
+          pcm_second = Bioinform::MotifModel::PCM.new(input_second[:matrix]).named(input_second[:name])
+          pwm_second = Bioinform::ConversionAlgorithms::PCM2PWMConverter.new(pseudocount: :log, background: second_background).convert(pcm_second)
+        when :pwm
+          pwm_first = Bioinform::MotifModel::PWM.new(input_first[:matrix]).named(input_first[:name])
+          pwm_second = Bioinform::MotifModel::PWM.new(input_second[:matrix]).named(input_second[:name])
+        end
+
+        pwm_first = pwm_first.discreted(discretization)
+        pwm_second = pwm_second.discreted(discretization)
+
+        counting_first = PWMCounting.new(pwm_first, background: first_background, max_hash_size: max_hash_size)
+        counting_second = PWMCounting.new(pwm_second, background: second_background, max_hash_size: max_hash_size)
+
+        cmp = Macroape::PWMCompareAligned.new(counting_first, counting_second, shift, orientation).tap{|x| x.max_pair_hash_size = max_pair_hash_size }
+
+        if predefined_threshold_first
+          threshold_first = predefined_threshold_first * discretization
+        else
+          if pvalue_boundary == :lower
+            threshold_first = counting_first.threshold(pvalue)
+          else
+            threshold_first = counting_first.weak_threshold(pvalue)
+          end
+        end
+
+        if predefined_threshold_second
+          threshold_second = predefined_threshold_second * discretization
+        else
+          if pvalue_boundary == :lower
+            threshold_second = counting_second.threshold(pvalue)
+          else
+            threshold_second = counting_second.weak_threshold(pvalue)
+          end
+        end
+        info = cmp.alignment_infos.merge( cmp.jaccard(threshold_first, threshold_second) )
+        info.merge!(predefined_threshold_first: predefined_threshold_first,
+                    predefined_threshold_second: predefined_threshold_second,
+                    threshold_first: threshold_first / discretization,
+                    threshold_second: threshold_second / discretization,
+                    discretization: discretization,
+                    first_background: first_background,
+                    second_background: second_background,
+                    requested_pvalue: pvalue,
+                    pvalue_boundary: pvalue_boundary)
+        puts Helper.similarity_info_string(info)
+
+      rescue => err
+        $stderr.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse --help option for help\n\n#{doc}"
+      end
+
+    end
+  end
+end