protk 1.2.1 → 1.2.2

data/bin/annotate_ids.rb

@@ -15,7 +15,7 @@ require 'protk/protein_annotator'
 
 # Setup specific command-line options for this tool. Other options are inherited from Tool
 #
-id_tool=ProphetTool.new({:explicit_output=>true,:over_write=>true})
+id_tool=ProphetTool.new([:explicit_output,:over_write])
 id_tool.option_parser.banner = "Run ID annotation on a prot.xml input file.\n\nUsage: annotate_ids.rb [options] file1.prot.xml"
 id_tool.options.output_prefix="annotated_"
 
@@ -25,7 +25,7 @@ id_tool.option_parser.on( '-I', '--input-format format', 'Format of input file'
   id_tool.options.input_format = format
 end
 
-id_tool.option_parser.parse!
+exit unless id_tool.check_options
 
 # Obtain a global environment object
 genv=Constants.new

data/bin/feature_finder.rb

@@ -13,7 +13,7 @@ require 'libxml'
 
 include LibXML
 
-tool=Tool.new({:explicit_output=>true, :background=>true,:over_write=>true,:prefix_suffix=>true})
+tool=Tool.new([:explicit_output, :background,:over_write,:prefix_suffix])
 tool.option_parser.banner = "Find molecular features on a set of input files.\n\nUsage: feature_finder.rb [options] file1.mzML file2.mzML ..."
 
 tool.options.intensity_type = "ref"
@@ -27,7 +27,13 @@ tool.option_parser.on( '--intensity-threshold thresh',"discard features below th
 end
 
 
-tool.option_parser.parse!
+exit unless tool.check_options 
+
+if ( ARGV[0].nil? )
+    puts "You must supply an input file"
+    puts tool.option_parser 
+    exit
+end
 
 # Obtain a global environment object
 genv=Constants.new

data/bin/file_convert.rb

@@ -57,7 +57,7 @@ end
 
 # Setup specific command-line options for this tool. Other options are inherited from Tool
 #
-convert_tool=Tool.new({:explicit_output=>true,:over_write=>true,:maldi=>true})
+convert_tool=Tool.new([:explicit_output,:over_write,:maldi])
 convert_tool.option_parser.banner = "Convert files between different formats.\n\nUsage: file_convert.rb [options] input_file output_file"
 
 # Special case (usually tool specific options use capitals). Use lowercase l here to mimick maldi option in the search_tool class
@@ -80,7 +80,13 @@ end
 
 
 
-convert_tool.option_parser.parse!
+exit unless convert_tool.check_options 
+
+if ( ARGV[0].nil? )
+    puts "You must supply an input file"
+    puts convert_tool.option_parser 
+    exit
+end
 
 
 

data/bin/gffmerge.rb

@@ -14,7 +14,7 @@ require 'bio'
 
 include LibXML
 
-tool=Tool.new(:explicit_output=>true)
+tool=Tool.new([:explicit_output])
 tool.option_parser.banner = "Create a gff containing peptide observations.\n\nUsage: gffmerge.rb "
 
 
@@ -43,21 +43,7 @@ tool.option_parser.on('--threshold prob','Peptide Probability Threshold (Default
   tool.options.peptide_probability_threshold=thresh.to_f
 end
 
-# Checking for required options
-begin
-  tool.option_parser.parse!
-  mandatory = [:protxml,:sixframe] 
-  missing = mandatory.select{ |param| tool.send(param).nil? }
-  if not missing.empty?                                            
-    puts "Missing options: #{missing.join(', ')}"                  
-    puts tool.option_parser                                                  
-    exit                                                           
-  end                                                              
-rescue OptionParser::InvalidOption, OptionParser::MissingArgument      
-  puts $!.to_s                                                           
-  puts tool.option_parser                                              
-  exit                                                                   
-end
+exit unless tool.check_options [:protxml,:sixframe]
 
 gff_out_file="merged.gff"
 if ( tool.explicit_output != nil)
@@ -109,6 +95,9 @@ protein_count = 0
 total_peptides = 0
 for prot in proteins
   prot_prob = prot['probability']
+  if ( prot_prob.to_f < tool.peptide_probability_threshold )
+    next
+  end
   indis_proteins = prot.find('protxml:indistinguishable_protein','protxml:http://regis-web.systemsbiology.net/protXML')
   prot_names = [prot['protein_name']]
   for protein in indis_proteins
@@ -121,10 +110,10 @@ for prot in proteins
     protein_count += 1
     prot_qualifiers = {"source" => "OBSERVATION", "score" => prot_prob, "ID" => 'pr' + protein_count.to_s}
     begin
-      p "Looking up #{protein_name}"
+      puts "Looking up #{protein_name}"
       orf = orf_lookup.get_by_id protein_name
       if ( orf == nil)
-        p "Failed lookup for #{protein_name}"
+        puts "Failed lookup for #{protein_name}"
         raise KeyError
       end
 
@@ -132,7 +121,7 @@ for prot in proteins
       position = orf.identifiers.description.split('|').collect { |pos| pos.to_i }
 
       if ( position.length != 2 )
-        p "Badly formatted entry #{orf}"
+        puts "Badly formatted entry #{orf}"
         raise EncodingError
       end
       orf_name = orf.entry_id.scan(/lcl\|(.*)/)[0][0]
@@ -151,6 +140,9 @@ for prot in proteins
       prot_seq = orf.aaseq.to_s
       throw "Not amino_acids" if prot_seq != orf.seq.to_s
 
+      if ( strand=='-' )
+        prot_seq.reverse!
+      end
 
       for peptide in peptides
         pprob = peptide['nsp_adjusted_probability'].to_f
@@ -158,6 +150,9 @@ for prot in proteins
           total_peptides += 1
           pep_seq = peptide['peptide_sequence']
 
+          if ( strand=='-')
+            pep_seq.reverse!
+          end
 
           start_indexes = [0]
           prot_seq.scan /#{pep_seq}/  do |match| 
@@ -178,7 +173,7 @@ for prot in proteins
               strand=strand,frame=nil,attributes=pep_attributes)
             fragment_gff_line = Bio::GFF::GFF3::Record.new(seqid = scaffold_name,source="OBSERVATION",
               feature_type="fragment",start_position=pep_genomic_start,end_position=pep_genomic_end,score='',
-              strand=strand,frame=nil,attributes=[["Parent",pep_id],["ID",pep_seq]])
+              strand=strand,frame=nil,attributes=[["Parent",pep_id],["ID",peptide['peptide_sequence']]])
             gff_db.records += [pep_gff_line,fragment_gff_line]
 
           end

data/bin/interprophet.rb

@@ -13,7 +13,7 @@ require 'protk/prophet_tool'
 
 # Setup specific command-line options for this tool. Other options are inherited from ProphetTool
 #
-prophet_tool=ProphetTool.new({:explicit_output=>true})
+prophet_tool=ProphetTool.new([:explicit_output])
 prophet_tool.option_parser.banner = "Run InterProphet on a set of pep.xml input files.\n\nUsage: interprophet.rb [options] file1.pep.xml file2.pep.xml ..."
 prophet_tool.options.output_suffix="_iproph"
 
@@ -48,8 +48,12 @@ prophet_tool.option_parser.on("--minprob mp","Minimum probability cutoff ") do |
   prophet_tool.options.min_prob=mp
 end
 
-prophet_tool.option_parser.parse!
-
+exit unless prophet_tool.check_options
+if ( ARGV[0].nil? )
+    puts "You must supply an input file"
+    puts prophet_tool.option_parser 
+    exit
+end
 
 # Obtain a global environment object
 genv=Constants.new

data/bin/make_decoy.rb

@@ -17,7 +17,7 @@ include LibXML
 
 # Setup specific command-line options for this tool. Other options are inherited from ProphetTool
 #
-tool=Tool.new({:explicit_output=>true})
+tool=Tool.new([:explicit_output])
 tool.option_parser.banner = "Create a decoy database from real protein sequences.\n\nUsage: make_decoy.rb [options] realdb.fasta"
 
 tool.options.db_length=0
@@ -36,7 +36,14 @@ tool.option_parser.on('-A','--append','Append input sequences to the generated d
 end
 
 
-tool.option_parser.parse!
+exit unless tool.check_options 
+
+if ( ARGV[0].nil? )
+    puts "You must supply an input file"
+    puts tool.option_parser 
+    exit
+end
+
 
 input_file=ARGV[0]
 

data/bin/mascot2xml.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+#
+# This file is part of protk
+# Created by Ira Cooke 12/4/2010
+#
+# Convert mascot dat files to pepxml without using TPP Mascot2XML 
+#
+
+
+require 'protk/constants'
+require 'protk/search_tool'
+require 'mascot/dat'
+require 'libxml'
+
+include LibXML
+
+
+
+
+# Environment with global constants
+#
+genv=Constants.new
+
+tool=SearchTool.new([:database,:explicit_output,:over_write])
+tool.option_parser.banner = "Convert mascot dat files to pep.xml files.\n\nUsage: mascot2xml.rb [options] file1.dat file2.dat ... "
+tool.option_parser.parse!
+
+throw "Only one file at a time is allowed when using explicit output" if (tool.explicit_output && ARGV.length > 1)
+
+def update_msms_pipeline_analysis(pepxml_doc,mascot_dat,outname)
+  pipeline_analysis_node=pepxml_doc.find("//#{$pepxml_ns_prefix}msms_pipeline_analysis", $pepxml_ns)[0]
+  pipeline_analysis_node.attributes['date']=Time.at(mascot_dat.header.date.to_i).to_s
+  pipeline_analysis_node.attributes['summary_xml']=outname
+end
+
+def update_enzyme(pepxml_doc,mascot_dat)
+  dat_enzyme=mascot_dat.enzyme
+  enzyme_node=pepxml_doc.find("//#{$pepxml_ns_prefix}sample_enzyme", $pepxml_ns)[0]
+  enzyme_node.attributes['name']=dat_enzyme.title
+  specificity=enzyme_node.find("./#{$pepxml_ns_prefix}specificity",$pepxml_ns)[0]
+#  p dat_enzyme.cleavages
+  # TODO: What does the spec say about multiple cut sites
+#  specificity.attributes['cut']=
+end
+
+
+
+ARGV.each do |file_name| 
+  name=file_name.chomp
+
+  dat = Mascot::DAT.open(name)
+  pepxml_template_parser=XML::Parser.file("#{genv.data_lib_dir}/pepxml_mascot_template.xml")
+  pepxml_doc = pepxml_template_parser.parse
+
+  outname = nil
+  if ( tool.explicit_output !=nil)
+    outname = tool.explicit_output
+  else
+    basename = Pathname.new(name).basename
+    outname = "#{basename}.pepXML"
+  end
+
+  $pepxml_ns_prefix="xmlns:"
+  $pepxml_ns="xmlns:http://regis-web.systemsbiology.net/pepXML"
+  if not pepxml_doc.root.namespaces.default
+    $pepxml_ns_prefix=""
+    $pepxml_ns=nil
+  end
+
+  update_msms_pipeline_analysis(pepxml_doc,dat,outname)
+  update_enzyme(pepxml_doc,dat)
+
+  spectrum_queries={}
+
+  dat.peptides.each do |psm|
+    # psm.score
+    qnum= psm.query
+    if qnum
+      qid=qnum.to_s
+      spectrum_queries[qid]=[] if ( spectrum_queries[qid]==nil) 
+      spectrum_queries[qid] << psm
+    end
+  end
+
+  spectrum_queries.each_pair { |name, val| p "#{name} #{val[0].pep}" }
+
+end

data/bin/mascot_search.rb

@@ -15,250 +15,189 @@ require 'rest_client'
 
 def login(mascot_cgi,username,password)
 
-  authdict={}
-  authdict[:username]=username
-  authdict[:password]=password
-  authdict[:action]="login"
-  authdict[:savecookie]="1"
-
-  p "Logging in to #{mascot_cgi}/login.pl"
-  p authdict
-  response = RestClient.post "#{mascot_cgi}/login.pl", authdict
-
-  cookie = response.cookies
-  cookie
+    authdict={}
+    authdict[:username]=username
+    authdict[:password]=password
+    authdict[:action]="login"
+    authdict[:savecookie]="1"
+
+    p "Logging in to #{mascot_cgi}/login.pl"
+    p authdict
+    response = RestClient.post "#{mascot_cgi}/login.pl", authdict
+
+    cookie = response.cookies
+    cookie
 end
 
-def export_results(mascot_cgi,session_cookie,results_path,format)
-  export_dict={}
-  export_dict[:generate_file]=1
-  export_dict[:pep_query]=1
-  export_dict[:file]=results_path #"../data/20130423/F208623.dat"
-  export_dict[:export_format]=format
-  export_dict[:protein_master]=1
-  export_dict[:prot_hit_num]=1
-  export_dict[:show_unassigned]=1
-  export_dict[:query_title]=1
-  export_dict[:pep_expect]=1
-  export_dict[:pep_rank]=1
-  export_dict[:search_master]=1
-  export_dict[:pep_var_mod]=1
-  export_dict[:pep_isbold]=1
-  export_dict[:report]=0
-  export_dict[:show_queries]=1
-  export_dict[:pep_exp_mz]=1
-  export_dict[:pep_exp_z]=1
-  export_dict[:query_master]=0
-  export_dict[:pep_scan_title]=1
-  export_dict[:query_qualifiers]=1
-  export_dict[:_showsubsets]=1
-  export_dict[:_sigthreshold]=0.99
-  export_dict[:pep_isunique]=1
-  export_dict[:show_header]=1
-  export_dict[:pep_ident]=1
-  export_dict[:query_peaks]=1
-  export_dict[:pep_seq]=1
-  export_dict[:query_raw]=1
-  export_dict[:pep_score]=1
-  export_dict[:show_same_sets]=1
-  export_dict[:do_export]=1
-  export_dict[:peptide_master]=1
-  export_dict[:prot_score]=1
-  export_dict[:prot_acc]=1
-  export_dict[:show_params]=1
-  export_dict[:pep_homol]=1
-  export_dict[:show_mods]=1
-
-  # RestClient.add_before_execution_proc do |req, params|
-  #   require 'debugger'; debugger
-  #   p req
-  #   p params
-  # end
-
-
-  export_url="#{mascot_cgi}/export_dat_2.pl"
-
-  begin
-    RestClient.post(export_url , export_dict , {:cookies=>session_cookie}){ |response, request, result, &block|
-      # require 'debugger'; debugger
-      if ( response.code==303)
-        sleep(5)
-      end
-      response.return!(request, result, &block)
-    }
-#    response = RestClient.post export_url , export_dict , {:cookies=>session_cookie}
-  rescue
-    p "Ignoring exception"
-      # require 'debugger'; debugger
-  end
-
-  begin
-    p response.to_s[0,1000]
-  rescue
-  end
-
-  fout = File.new("results.xml",  "w+")
-
-  fout.write response
+def download_datfile(mascot_cgi,results_date,results_file,explicit_output,openurlcookie)
+    mascot_xcgi = "#{mascot_cgi.chomp('cgi')}x-cgi"
+    get_url= "#{mascot_xcgi}/ms-status.exe?Autorefresh=false&Show=RESULTFILE&DateDir=#{results_date}&ResJob=#{results_file}"
+    $genv.log("Getting results file at #{get_url}",:info)
+    
+    if ( explicit_output!=nil)
+        output_path=explicit_output
+    else
+        output_path="#{results_file}"
+    end
+
+    require 'open-uri'
+    open("#{output_path}", 'wb') do |file|
+        file << open("#{get_url}","Cookie"=>openurlcookie).read
+    end
 end
 
+
 def search_params_dictionary(search_tool,input_file)
-  var_mods = search_tool.var_mods.split(",").collect { |mod| mod.lstrip.rstrip }.reject {|e| e.empty? }.join(",")
-  fix_mods = search_tool.fix_mods.split(",").collect { |mod| mod.lstrip.rstrip }.reject { |e| e.empty? }.join(",")
-
-  # None is given by a an empty galaxy multi-select list and we need to turn it into an empty string
-  #
-  var_mods=""  if var_mods=="None"
-  fix_mods="" if fix_mods=="None"
-
-  postdict={}
-  postdict[:SEARCH]="MIS" 
-  postdict[:CHARGE]=search_tool.allowed_charges
-  postdict[:CLE]=search_tool.enzyme
-  postdict[:PFA]=search_tool.missed_cleavages
-  postdict[:COM]="Protk"
-  postdict[:DB]=search_tool.database
-  postdict[:INSTRUMENT]=search_tool.instrument
-  postdict[:IT_MODS]=var_mods
-  postdict[:ITOL]=search_tool.fragment_tol
-  postdict[:ITOLU]=search_tool.fragment_tolu
-  postdict[:MASS]=search_tool.precursor_search_type
-  postdict[:MODS]=fix_mods
-  postdict[:REPORT]="AUTO"
-  postdict[:TAXONOMY]="All entries"
-  postdict[:TOL]=search_tool.precursor_tol
-  postdict[:TOLU]=search_tool.precursor_tolu
-  postdict[:USEREMAIL]=search_tool.email
-  postdict[:USERNAME]=search_tool.username
-  postdict[:FILE]=File.new(input_file)
-  postdict[:FORMVER]='1.01'
-  postdict[:INTERMEDIATE]=''
-
-  postdict
+    var_mods = search_tool.var_mods.split(",").collect { |mod| mod.lstrip.rstrip }.reject {|e| e.empty? }.join(",")
+    fix_mods = search_tool.fix_mods.split(",").collect { |mod| mod.lstrip.rstrip }.reject { |e| e.empty? }.join(",")
+
+    # None is given by a an empty galaxy multi-select list and we need to turn it into an empty string
+    #
+    var_mods=""  if var_mods=="None"
+    fix_mods="" if fix_mods=="None"
+
+    postdict={}
+    postdict[:SEARCH]="MIS" 
+    postdict[:CHARGE]=search_tool.allowed_charges
+    postdict[:CLE]=search_tool.enzyme
+    postdict[:PFA]=search_tool.missed_cleavages
+    postdict[:COM]="Protk"
+    postdict[:DB]=search_tool.database
+    postdict[:INSTRUMENT]=search_tool.instrument
+    postdict[:IT_MODS]=var_mods
+    postdict[:ITOL]=search_tool.fragment_tol
+    postdict[:ITOLU]=search_tool.fragment_tolu
+    postdict[:MASS]=search_tool.precursor_search_type
+    postdict[:MODS]=fix_mods
+    postdict[:REPORT]="AUTO"
+    postdict[:TAXONOMY]="All entries"
+    postdict[:TOL]=search_tool.precursor_tol
+    postdict[:TOLU]=search_tool.precursor_tolu
+    postdict[:USEREMAIL]=search_tool.email
+    postdict[:USERNAME]=search_tool.username
+    postdict[:FILE]=File.new(input_file)
+    postdict[:FORMVER]='1.01'
+    postdict[:INTERMEDIATE]=''
+
+    postdict
 end
 
 # Environment with global constants
 #
-genv=Constants.new
+$genv=Constants.new
 
 # Setup specific command-line options for this tool. Other options are inherited from SearchTool
 #
-search_tool=SearchTool.new({:msms_search=>true,:background=>false,:database=>true,:explicit_output=>true,:over_write=>true,:msms_search_detailed_options=>true})
+search_tool=SearchTool.new([:explicit_output,:over_write,:database,:enzyme,
+    :modifications,:instrument,:mass_tolerance,
+    :mass_tolerance_units,:precursor_search_type,:missed_cleavages])
 
 search_tool.jobid_prefix="o"
 
-search_tool.option_parser.banner = "Run a Mascot msms search on a set of mgf input files.\n\nUsage: mascot_search.rb [options] file1.mgf file2.mgf ..."
+search_tool.option_parser.banner = "Run a Mascot msms search on a set of mgf input files.\n\nUsage: mascot_search.rb [options] msmsfile.mgf"
 search_tool.options.output_suffix="_mascot"
 
-search_tool.options.mascot_server="#{genv.default_mascot_server}/mascot/cgi"
+search_tool.options.mascot_server="#{$genv.default_mascot_server}/mascot/cgi"
+
+search_tool.options.allowed_charges="1+,2+,3+"
+search_tool.option_parser.on(  '--allowed-charges ac', 'Allowed precursor ion charges. Default=1+,2+,3+' ) do |ac|
+ search_tool.options.allowed_charges = ac
+end     
+
+search_tool.options.email=""
+search_tool.option_parser.on('--email em', 'User email.') do |em|
+    search_tool.options.email = em
+end
+
+search_tool.options.username=""
+search_tool.option_parser.on('--username un', 'Username.') do |un|
+    search_tool.options.username = un
+end
+
+search_tool.options.mascot_server="www.matrixscience.com"
+search_tool.option_parser.on( '-S', '--server url', 'The url to the cgi directory of the mascot server' ) do |url| 
+    search_tool.options.mascot_server=url
+end
+
+search_tool.options.mascot_server=""
+search_tool.option_parser.on('--username un', 'Username.') do |un|
+    search_tool.options.username = un
+end
 
 search_tool.options.httpproxy=""
 search_tool.option_parser.on( '--proxy url', 'The url to a proxy server' ) do |urll| 
-   search_tool.options.httpproxy=urll
+    search_tool.options.httpproxy=urll
 end
 
 search_tool.options.mascot_password=""
 search_tool.option_parser.on( '--password psswd', 'Password to use when Mascot security is enabled' ) do |psswd| 
-  search_tool.options.mascot_password=psswd
+    search_tool.options.mascot_password=psswd
 end
 
 search_tool.options.use_security=FALSE
 search_tool.option_parser.on( '--use-security', 'When Mascot security is enabled this is required' ) do  
-  search_tool.options.use_security=TRUE
+    search_tool.options.use_security=TRUE
 end
 
-search_tool.option_parser.parse!
+search_tool.options.export_format="mascotdat"
+search_tool.option_parser.on( '--export format', 'Save results in a specified format. Only mascotdat is currently supported' ) do |format| 
+    search_tool.options.export_format=format
+end
 
+exit unless search_tool.check_options 
+
+if ( ARGV[0].nil? )
+    puts "You must supply an input file"
+    puts search_tool.option_parser 
+    exit
+end
 
 fragment_tol = search_tool.fragment_tol
 precursor_tol = search_tool.precursor_tol
 
-
-
 mascot_cgi=search_tool.mascot_server.chomp('/')
 
 unless ( mascot_cgi =~ /^http[s]?:\/\//)
-  mascot_cgi  = "http://#{mascot_cgi}"
+    mascot_cgi  = "http://#{mascot_cgi}"
 end
 
-mascot_xcgi = "#{mascot_cgi.chomp('cgi')}x-cgi"
-
-#
 RestClient.proxy=search_tool.httpproxy
 
-genv.log("Var mods #{search_tool.var_mods} and fixed #{search_tool.fix_mods}",:info)
-
-
+$genv.log("Var mods #{search_tool.var_mods} and fixed #{search_tool.fix_mods}",:info)
 
 cookie=""
 openurlcookie=""
 
 if ( search_tool.use_security)
-  # Login
-  #
-  genv.log("Logging in",:info)
-
-  # authdict={}
-  # authdict[:username]=search_tool.username
-  # authdict[:password]=search_tool.mascot_password
-  # authdict[:action]="login"
-  # authdict[:savecookie]="1"
-
-  # response = RestClient.post "#{mascot_cgi}/login.pl", authdict
-
-  cookie = login(mascot_cgi,search_tool.username,search_tool.mascot_password)
-
-  #cookie = response.cookies
-  openurlcookie = "MASCOT_SESSION=#{cookie['MASCOT_SESSION']}; MASCOT_USERID=#{cookie['MASCOT_USERID']}; MASCOT_USERNAME=#{cookie['MASCOT_USERNAME']}"
+    $genv.log("Logging in",:info)
+    cookie = login(mascot_cgi,search_tool.username,search_tool.mascot_password)
+    openurlcookie = "MASCOT_SESSION=#{cookie['MASCOT_SESSION']}; MASCOT_USERID=#{cookie['MASCOT_USERID']}; MASCOT_USERNAME=#{cookie['MASCOT_USERNAME']}"
 end
 
 postdict = search_params_dictionary search_tool, ARGV[0]
-
-
-genv.log("Sending #{postdict}",:info)
-
+$genv.log("Sending #{postdict}",:info)
 
 search_response=RestClient.post "#{mascot_cgi}/nph-mascot.exe?1",  postdict, {:cookies=>cookie}
 
-genv.log("Mascot search response was #{search_response}",:info)
+$genv.log("Mascot search response was #{search_response}",:info)
 
 # Look for an error if there is one
 error_result= /Sorry, your search could not be performed(.*)/.match(search_response)
 if ( error_result != nil )
-  p error_result[0]
-  genv.log("Mascot search failed with response #{search_response}",:warn)
-  throw "Mascot search failed with response #{search_response}"
+    puts error_result[0]
+    $genv.log("Mascot search failed with response #{search_response}",:warn)
+    throw "Mascot search failed with response #{search_response}"
+elsif (search_tool.export_format=="mascotdat")
+    # Search for the location of the mascot data file in the response
+    results=/master_results_?2?\.pl\?file=\.*\/data\/(.*)\/(.+\.dat)/.match(search_response)
+    results_date=results[1]
+    results_file=results[2]
+
+    download_datfile mascot_cgi, results_date, results_file,search_tool.explicit_output,openurlcookie
 else
-
-  # Search for the location of the mascot data file in the response
-  results=/master_results_?2?\.pl\?file=\.*\/data\/(.*)\/(.+\.dat)/.match(search_response)
-  results_date=results[1]
-  results_file=results[2]
-
-#  results=/master_results_?2?\.pl\?file=(\.*\/data\/.*\/.+\.dat)/.match(search_response)
-#  results_file = results[1]
-#  export_results mascot_cgi,cookie,results_file,"XML"
-
-
-  get_url= "#{mascot_xcgi}/ms-status.exe?Autorefresh=false&Show=RESULTFILE&DateDir=#{results_date}&ResJob=#{results_file}"
-
-  genv.log("Getting results file at #{get_url}",:info)
-
-  if ( search_tool.explicit_output!=nil)
-    output_path=search_tool.explicit_output
-  else
-    output_path="#{results_file}"
-  end
-
-  # Download the results
-  #
-  require 'open-uri'
-  open("#{output_path}", 'wb') do |file|
-    file << open("#{get_url}","Cookie"=>openurlcookie).read
-  end
-
-
-#open("F1.dat", 'wb') do |file| file << open("#{get_url}","Cookie" => cookie).read end
-
+    results=/master_results_?2?\.pl\?file=(\.*\/data\/.*\/.+\.dat)/.match(search_response)
+    results_file = results[1]
+    export_results mascot_cgi,cookie,results_file,search_tool.export_format, openurlcookie
+#    export_results mascot_cgi,cookie,results_file,search_tool.export_format
 end