Class: Bio::BWA

Inherits:
Object
  • Object
show all
Extended by:
FFI::Library
Defined in:
lib/bio/bwa.rb,
lib/bio/bwa/library.rb

Overview

Author:

Defined Under Namespace

Classes: Library

Class Method Summary collapse

Class Method Details

.bwt2sa(params = {}) ⇒ Object

Generate SA file from BWT and Occ files

Parameters:

  • . (Hash) —

    params Options.

  • params (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (params):

  • :file_in (String) —

    the PAC file (REQUIRED)

  • :file_out (String) —

    the name of the REV PAC (REQUIRED)



60
61
62
63
64
65
66
 
# File 'lib/bio/bwa.rb', line 60

def self.bwt2sa(params={})
  valid_params = %w(file_in file_out i)
  last_params = [:file_in,:file_out]
  check_mandatory(last_params, params)
  args = build_parameters("bwt2sa",valid_params,params,last_params)
  call_BWA_function(args)
end

.bwtupdate(params = {}) ⇒ Object

Note:

this method overwrite existing BWT file

Convert a BWT file to the new BWT format

Parameters:

  • . (Hash) —

    params Options.

  • params (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (params):

  • :file_in (String) —

    the BWT file (REQUIRED)



36
37
38
39
40
41
42
 
# File 'lib/bio/bwa.rb', line 36

def self.bwtupdate(params={})
  valid_params = %w(file_in)
  last_params = [:file_in]
  check_mandatory(last_params, params)
  args = build_parameters("bwtupdate",valid_params,params,last_params)
  call_BWA_function(args)
end

.change_arg_name(hash, key, new_key) ⇒ Object

Note:

this method should not be called directly

Internal method used to change parameters name from Ruby to BWA functions



297
298
299
300
301
 
# File 'lib/bio/bwa.rb', line 297

def self.change_arg_name(hash,key,new_key)
  hash[new_key] = hash[key]
  hash.delete(key)
  return hash
end

.fa2pac(params = {}) ⇒ Object

Convert a Fasta to Packed format

Parameters:

  • . (Hash) —

    params Options.

  • params (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (params):

  • :file_in (String) —

    the Fasta or FastQ file (REQUIRED)

  • :prefix (String) —

    the prefix name for the PAC file



11
12
13
14
15
16
17
18
 
# File 'lib/bio/bwa.rb', line 11

def self.fa2pac(params={})
  valid_params = %w(file_in prefix)
  last_params = [:file_in, :prefix]
  mandatory_params = [:file_in]
  check_mandatory(mandatory_params, params)
  args = build_parameters("fa2pac",valid_params,params,last_params)
  call_BWA_function(args)
end

.long_read_alignment(params = {}) ⇒ Object

Note:

Boolean arguments must be set to ‘true’

Run the alignment for long query sequences

Parameters:

  • params (Hash) (defaults to: {}) —

    Options

Options Hash (params):

  • :file_in (String) —

    the FastQ file (REQUIRED)

  • :prefix (String) —

    the prefix of the database index files (REQUIRED)

  • :file_out (String) —

    the output of the alignment in SAM format (REQUIRED)

  • :a (Integer) —

    score for a match [1]

  • :b (Integer) —

    mismatch penalty [3]

  • :q (Integer) —

    gap open penalty [5]

  • :r (Integer) —

    gap extension penalty [2]

  • :t (Integer) —

    number of threads [1]

  • :w (Integer) —

    band width [50]

  • :m (Float) —

    mask level [0.50]

  • :T (Integer) —

    score threshold divided by a [30]

  • :s (Integer) —

    maximum seeding interval size [3]

  • :z (Integer) —

    Z-best [1]

  • :N (Integer) —

    number of seeds to trigger reverse alignment [5]

  • :c (Float) —

    coefficient of length-threshold adjustment [5.5]

  • :H (Boolean) —

    in SAM output, use hard clipping rather than soft



203
204
205
206
207
208
209
210
211
 
# File 'lib/bio/bwa.rb', line 203

def self.long_read_alignment(params = {})
  valid_params = %w(q r a b t T w d z m y s c N H f prefix file_in)
  mandatory_params = [:prefix, :file_in, :file_out]
  last_params = [:prefix,:file_in]
  check_mandatory(mandatory_params, params)
  params = change_arg_name(params,:file_out,:f) if params[:file_out]  
  args = build_parameters("bwtsw2",valid_params,params,last_params)
  call_BWA_function(args)
end

.make_index(params = {}) ⇒ Object

Note:

Boolean values must be set to ‘true’

Generate the BWT index for a Fasta database

Parameters:

  • . (Hash) —

    params Options.

  • params (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (params):

  • :file_in (String) —

    the Fasta file (REQUIRED)

  • :p (String) —

    the prefix for the database files that will be generated [default is Fasta name]

  • :a (String) —

    the algorithm to be used for indexing: ‘is’ (short database) or ‘bwtsw’ (long database)

  • :c (Boolean) —

    colorspace database index



75
76
77
78
79
80
81
82
83
 
# File 'lib/bio/bwa.rb', line 75

def self.make_index(params = {})
  valid_params = %w(file_in p a c)
  mandatory_params = [:file_in]
  last_params = [:file_in]
  check_mandatory(mandatory_params, params)
  params = change_arg_name(params,:prefix,:p) if params[:prefix]
  args = build_parameters("index",valid_params,params,last_params)        
  call_BWA_function(args)
end

.pac2bwt(params = {}) ⇒ Object

Convert a Packed file format to Burrows-Wheeler Transform format

Parameters:

  • . (Hash) —

    params Options.

  • params (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (params):

  • :file_in (String) —

    the PAC file (REQUIRED)

  • :file_out (String) —

    the name of the BWT file (REQUIRED)



24
25
26
27
28
29
30
 
# File 'lib/bio/bwa.rb', line 24

def self.pac2bwt(params={})
  valid_params = %w(file_in file_out)
  last_params = [:file_in,:file_out]
  check_mandatory(last_params, params)
  args = build_parameters("pac2bwt",valid_params,params,last_params)
  call_BWA_function(args)
end

.pac_rev(params = {}) ⇒ Object

Generate reverse Packed format

Parameters:

  • . (Hash) —

    params Options.

  • params (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (params):

  • :file_in (String) —

    the PAC file (REQUIRED)

  • :file_out (String) —

    the name of the REV PAC (REQUIRED)



48
49
50
51
52
53
54
 
# File 'lib/bio/bwa.rb', line 48

def self.pac_rev(params={})
  valid_params = %w(file_in file_out)
  last_params = [:file_in,:file_out]
  check_mandatory(last_params, params)
  args = build_parameters("pac_rev",valid_params,params,last_params)
  call_BWA_function(args)
end

.sai_to_sam_paired(params = {}) ⇒ Object

Note:

Boolean values must be set to ‘true’

Convert the SAI alignment output into SAM format (paired ends)

Parameters:

  • params (Hash) (defaults to: {}) —

    Options

Options Hash (params):

  • :prefix (String) —

    the prefix of the database index files (REQUIRED)

  • :sai (Array) —

    the two alignment files in SAI format (REQUIRED)

  • :fastq (Array) —

    the two fastq files (REQUIRED)

  • :a (Integer) —

    maximum insert size [500]

  • :o (Integer) —

    maximum occurrences for one end [100000]

  • :n (Integer) —

    maximum hits to output for paired reads [3]

  • :N (Integer) —

    maximum hits to output for discordant pairs [10]

  • :c (Float) —

    prior of chimeric rate (lower bound) [1.0e-05]

  • :r (String) —

    read group header line such as ‘@RGtID:footSM:bar’

  • :P (Boolean) —

    preload index into memory (for base-space reads only)

  • :s (Boolean) —

    disable Smith-Waterman for the unmapped mate

  • :A (Boolean) —

    disable insert size estimate (force :s)



162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/bio/bwa.rb', line 162

def self.sai_to_sam_paired(params = {})
  valid_params = %w(a o s P n N c f A r prefix first_sai second_sai first_fastq second_fastq)
  mandatory_params = [:prefix, :sai, :fastq]
  last_params = [:prefix, :first_sai, :second_sai, :first_fastq, :second_fastq]
  check_mandatory(mandatory_params, params)
  params = change_arg_name(params,:file_out,:f) if params[:file_out]
  if params[:sai]
    raise ArgumentError,"you must provide an array with two SAI files!" unless params[:sai].is_a?(Array) and params[:sai].size == 2
    params[:first_sai] = params[:sai][0]
    params[:second_sai] = params[:sai][1]
    params.delete(:sai)
  end
  if params[:fastq]
    raise ArgumentError,"you must provide an array with two FastQ files!" unless params[:fastq].is_a?(Array) and params[:fastq].size == 2
    params[:first_fastq] = params[:fastq][0]
    params[:second_fastq] = params[:fastq][1]
    params.delete(:fastq)
  end
  args = build_parameters("sai2sam_pe",valid_params,params,last_params)
  call_BWA_function(args)
end

.sai_to_sam_single(params = {}) ⇒ Object

Convert the SAI alignment output into SAM format (single end)

Parameters:

  • params (Hash) (defaults to: {}) —

    Options

Options Hash (params):

  • :fastq (String) —

    the FastQ file (REQUIRED)

  • :prefix (String) —

    the prefix of the database index files (REQUIRED)

  • :sai (String) —

    the alignment file in SAI format (REQUIRED)

  • :file_out (String) —

    the file name of the SAM output

  • :n (Integer) —

    max_occ

  • :r (String) —

    RG_line



136
137
138
139
140
141
142
143
144
 
# File 'lib/bio/bwa.rb', line 136

def self.sai_to_sam_single(params = {})
  valid_params = %w(n r fastq sai prefix f)
  mandatory_params = [:prefix,:sai,:fastq]
  last_params = [:prefix,:sai,:fastq]
  check_mandatory(mandatory_params, params)
  params = change_arg_name(params,:file_out,:f) if params[:file_out]
  args = build_parameters("sai2sam_se",valid_params,params,last_params)
  call_BWA_function(args)
end

.short_read_alignment(params = {}) ⇒ Object

Note:

Boolean values must be set to ‘true’

Run the alignment for short query sequences

Parameters:

  • params (Hash) (defaults to: {}) —

    Options

Options Hash (params):

  • :file_in (String) —

    the FastQ file (REQUIRED)

  • :prefix (String) —

    the prefix of the database index files (REQUIRED)

  • :file_out (String) —

    the output of the alignment in SAI format (REQUIRED)

  • :n (Integer) —

    max #diff (int) or missing prob under 0.02 err rate (float) [0.04]

  • :o (Integer) —

    maximum number or fraction of gap opens [1]

  • :e (Integer) —

    maximum number of gap extensions, -1 for disabling long gaps [-1]

  • :m (Integer) —

    maximum entries in the queue [2000000]

  • :t (Integer) —

    number of threads [1]

  • :M (Integer) —

    mismatch penalty [3]

  • :O (Integer) —

    gap open penalty [11]

  • :R (Integer) —

    stop searching when there are >INT equally best hits [30]

  • :q (Integer) —

    quality threshold for read trimming down to 35bp [0]

  • :B (Integer) —

    length of barcode

  • :c (Boolean) —

    input sequences are in the color space

  • :L (Boolean) —

    log-scaled gap penalty for long deletions

  • :N (Boolean) —

    non-iterative mode: search for all n-difference hits (slow)

  • :I (Boolean) —

    the input is in the Illumina 1.3+ FASTQ-like format

  • :b (Boolean) —

    the input read file is in the BAM format

  • :single (Boolean) —

    use single-end reads only (effective with -b)

  • :first (Boolean) —

    use the 1st read in a pair (effective with -b)

  • :second (Boolean) —

    use the 2nd read in a pair (effective with -b)

  • :i (Integer) —

    do not put an indel within INT bp towards the ends [5]

  • :d (Integer) —

    maximum occurrences for extending a long deletion [10]

  • :l (Integer) —

    seed length [32]

  • :k (Integer) —

    maximum differences in the seed [2]

  • :E (Integer) —

    gap extension penalty [4]



114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/bio/bwa.rb', line 114

def self.short_read_alignment(params={})
    args = ["aln"]
    valid_params = %w(n o e i d l k c L R m t N M O E q f b single first second I B prefix file_in)
    mandatory_params = [:prefix,:file_in,:file_out]
    last_params = [:prefix,:file_in]
    check_mandatory(mandatory_params, params)
    params = change_arg_name(params,:file_out,:f) if params[:file_out]
    params = change_arg_name(params,:single,"0") if params[:single]
    params = change_arg_name(params,:first,"1") if params[:first]   
    params = change_arg_name(params,:second,"2") if params[:second]
    args = build_parameters("aln",valid_params,params,last_params)
    call_BWA_function(args)
end

.simple_SW(params = {}) ⇒ Object

Note:

Boolean values must be set to ‘true’

Run the alignment between multiple short sequences and ONE long sequence

Parameters:

  • params (Hash) (defaults to: {}) —

    Options

Options Hash (params):

  • :short_seq (String) —

    the short query sequence (REQUIRED)

  • :long_seq (String) —

    the long database sequence (REQUIRED)

  • :file_out (String) —

    the alignment output

  • :T (Integer) —

    minimum score [1]

  • :p (Boolean) —

    protein alignment (suppressing :r)

  • :f (Boolean) —

    forward strand only

  • :r (Boolean) —

    reverse strand only

  • :g (Boolean) —

    global alignment



224
225
226
227
228
229
230
231
232
233
234
235
236
 
# File 'lib/bio/bwa.rb', line 224

def self.simple_SW(params = {})
  args = ["stdsw"]
  valid_params = %w(g T f r p file_out long_seq short_seq)
  mandatory_params = [:long_seq,:short_seq]
  last_params = mandatory_params
  check_mandatory(mandatory_params, params)
  file_out = params[:file_out]
  params.delete(:file_out)
  args = build_parameters("stdsw",valid_params,params,last_params)
  $stdout.reopen(file_out,"w") if file_out
  call_BWA_function(args)
  $stdout.reopen("/dev/tty","w") if file_out
end