Bio::Tools::Run::StandAloneBlast man page on Fedora

Man page or keyword search:  
man Server   31170 pages
apropos Keyword Search (all sections)
Output format
Fedora logo
[printable version]

Bio::Tools::Run::StandUsereContributed PerlBio::Tools::Run::StandAloneBlast(3)

NAME
       Bio::Tools::Run::StandAloneBlast - Object for the local execution of
       the NCBI BLAST program suite (blastall, blastpgp, bl2seq).  There is
       experimental support for WU-Blast and NCBI rpsblast.

SYNOPSIS
	# Local-blast "factory object" creation and blast-parameter
	# initialization:
	@params = (-database => 'swissprot', -outfile => 'blast1.out');
	$factory = Bio::Tools::Run::StandAloneBlast->new(@params);

	# Blast a sequence against a database:
	$str = Bio::SeqIO->new(-file=>'t/amino.fa', -format => 'Fasta');
	$input = $str->next_seq();
	$input2 = $str->next_seq();
	$blast_report = $factory->blastall($input);

	# Run an iterated Blast (psiblast) of a sequence against a database:
	$factory->j(3);	   # 'j' is blast parameter for # of iterations
	$factory->outfile('psiblast1.out');
	$factory = Bio::Tools::Run::StandAloneBlast->new(@params);
	$blast_report = $factory->blastpgp($input);

	# Use blast to align 2 sequences against each other:
	$factory = Bio::Tools::Run::StandAloneBlast->new(-outfile => 'bl2seq.out');
	$factory->bl2seq($input, $input2);

	# Experimental support for WU-Blast 2.0
	my $factory = Bio::Tools::Run::StandAloneBlast->new(-program =>"wublastp",
							    -database =>"swissprot",
							    -e => 1e-20);
	my $blast_report = $factory->wublast($seq);

	# Experimental support for NCBI rpsblast
	my $factory = Bio::Tools::Run::StandAloneBlast->new(-db => 'CDD/Cog',
							    -expect => 0.001);
	$factory->F('T'); # turn on SEG filtering of query sequence
	my $blast_report = $factory->rpsblast($seq);

	# Use the experimental fast Blast parser, 'blast_pull'
	my $factory = Bio::Tools::Run::StandAloneBlast->new(-_READMETHOD =>'blast_pull',
							    @other_params);

	# Various additional options and input formats are available,
	# see the DESCRIPTION section for details.

DESCRIPTION
       This DESCRIPTION only documents Bio::Tools::Run::StandAloneBlast: - a
       Bioperl object for running the NCBI standAlone BLAST package. Blast
       itself, is a large & complex program - for more information regarding
       BLAST, please see the BLAST documentation which accompanies the BLAST
       distribution. BLAST is available from ftp://ncbi.nlm.nih.gov/blast/.

       A source of confusion in documenting a BLAST interface is that the term
       "program" is used in - at least - three different ways in the BLAST
       documentation. In this DESCRIPTION, "program" will refer to the BLAST
       routine set by the BLAST "-p" parameter that can be set to blastn,
       blastp, tblastx etc. We will use the term Blast "executable" to refer
       to the various different executable files that may be called - ie.
       blastall, blastpgp or bl2seq. In addition, there are several BLAST
       capabilities, which are also referred to as "programs", and are
       implemented by using specific combinations of BLAST executables,
       programs and parameters. They will be referred by their specific names
       - eg PSIBLAST and PHIBLAST.

       Before running StandAloneBlast it is necessary: to install BLAST on
       your system, to edit set the environmental variable $BLASTDIR or your
       $PATH variable to point to the BLAST directory, and to ensure that
       users have execute privileges for the BLAST program.

       If the databases which will be searched by BLAST are located in the
       data subdirectory of the blast program directory (the default
       installation location), StandAloneBlast will find them; however, if the
       database files are located in any other location, environmental
       variable $BLASTDATADIR will need to be set to point to that directory.

       The use of the StandAloneBlast module is as follows: Initially, a local
       blast "factory object" is created. The constructor may be passed an
       optional array of (non-default) parameters to be used by the factory,
       eg:

	@params = (-program => 'blastn', -database => 'ecoli.nt');
	$factory = Bio::Tools::Run::StandAloneBlast->new(@params);

       Any parameters not explicitly set will remain as the defaults of the
       BLAST executable. Note each BLAST executable has somewhat different
       parameters and options. See the BLAST Documentation for a description
       or run the BLAST executable from the command line followed solely with
       a "-" to see a list of options and default values for that executable;
       eg >blastall -.

       BLAST parameters can be changed and/or examined at any time after the
       factory has been created. The program checks that any parameter/switch
       being set/read is valid. Except where specifically noted,
       StandAloneBlast uses the same single-letter, case-sensitive parameter
       names as the actual blast program. Currently no checks are included to
       verify that parameters are of the proper type (e.g. string or numeric)
       or that their values are within the proper range.

       As an example, to change the value of the Blast parameter 'e' ('e' is
       the parameter for expectation-value cutoff)

	 $expectvalue = 0.01;
	 $factory->e($expectvalue);

       Note that for improved script readibility one can modify the name of
       the (ncbi) BLAST parameters as desired as long as the initial letter
       (and case) of the parameter are preserved, e.g.:

	 $factory->expectvalue($expectvalue);

       Unfortunately, some of the BLAST parameters are not the single letter
       one might expect (eg "iteration round" in blastpgp is 'j').  Again one
       can check by using, for example:

	 > blastpgp -

       Wublast parameters need to be complete (ie. don't truncate them to
       their first letter), but are case-insensitive.

       Once the factory has been created and the appropriate parameters set,
       one can call one of the supported blast executables. The input
       sequence(s) to these executables may be fasta file(s) as described in
       the BLAST documentation.

	 $inputfilename = 't/testquery.fa';
	 $blast_report = $factory->blastall($inputfilename);

       In addition, sequence input may be in the form of either a Bio::Seq
       object or (a reference to) an array of Bio::Seq objects, e.g.:

	 $input = Bio::Seq->new(-id => "test query",
				-seq => "ACTACCCTTTAAATCAGTGGGGG");
	 $blast_report = $factory->blastall($input);

       NOTE: Use of the BPlite method has been deprecated and is no longer
       supported.

       For blastall and non-psiblast blastpgp runs, report object is
       aBio::SearchIO object, selected by the user with the parameter
       _READMETHOD. The leading underscore is needed to distinguish this
       option from options which are passed to the BLAST executable. The
       default parser is Bio::SearchIO::blast. In any case, the "raw" blast
       report is also available. The filename is set by the 'outfile'
       parameter and has the default value of "blastreport.out".

       For psiblast execution in the BLAST "jumpstart" mode, the program must
       be passed (in addition to the query sequence itself) an alignment
       containing the query sequence (in the form of a SimpleAlign object) as
       well as a "mask" specifying at what residues position-specific scoring
       matrices (PSSMs) are to used and at what residues default scoring
       matrices (eg BLOSUM) are to be used. See psiblast documentation for
       more details. The mask itself is a string of 0's and 1's which is the
       same length as each sequence in the alignment and has a "1" at
       locations where (PSSMs) are to be used and a "0" at all other
       locations. So for example:

	 $str = Bio::AlignIO->new(-file => "cysprot.msf",
				  -format => 'msf');
	 $aln = $str->next_aln();
	 $len = $aln->length_aln();
	 $mask = '1' x $len;
	 # simple case where PSSM's to be used at all residues
	 $report = $factory->blastpgp("cysprot1.fa", $aln, $mask);

       For bl2seq execution, StandAloneBlast.pm can be combined with
       AlignIO.pm to directly produce a SimpleAlign object from the alignment
       of the two sequences produced by bl2seq as in:

	 # Get 2 sequences
	 $str = Bio::SeqIO->new(-file=>'t/amino.fa' , -format => 'Fasta');
	 my $seq3 = $str->next_seq();
	 my $seq4 = $str->next_seq();

	 # Run bl2seq on them
	 $factory = Bio::Tools::Run::StandAloneBlast->new(-program => 'blastp',
							  -outfile => 'bl2seq.out');
	 my $bl2seq_report = $factory->bl2seq($seq3, $seq4);

	 # Use AlignIO.pm to create a SimpleAlign object from the bl2seq report
	 $str = Bio::AlignIO->new(-file=> 'bl2seq.out',-format => 'bl2seq');
	 $aln = $str->next_aln();

       For more examples of syntax and use of StandAloneBlast.pm, the user is
       encouraged to run the scripts standaloneblast.pl in the bioperl
       examples/tools directory and StandAloneBlast.t in the bioperl t/
       directory.

FEEDBACK
   Mailing Lists
       User feedback is an integral part of the evolution of this and other
       Bioperl modules. Send your comments and suggestions preferably to one
       of the Bioperl mailing lists.  Your participation is much appreciated.

	 bioperl-l@bioperl.org			- General discussion
	 http://bioperl.org/wiki/Mailing_lists	- About the mailing lists

   Support
       Please direct usage questions or support issues to the mailing list:

       bioperl-l@bioperl.org

       rather than to the module maintainer directly. Many experienced and
       reponsive experts will be able look at the problem and quickly address
       it. Please include a thorough description of the problem with code and
       data examples if at all possible.

   Reporting Bugs
       Report bugs to the Bioperl bug tracking system to help us keep track
       the bugs and their resolution.  Bug reports can be submitted via the
       web:

	 http://bugzilla.open-bio.org/

AUTHOR - Peter Schattner
       Email schattner at alum.mit.edu

MAINTAINER - Torsten Seemann
       Email torsten at infotech.monash.edu.au

CONTRIBUTORS
       Sendu Bala  bix@sendu.me.uk (reimplementation)

APPENDIX
       The rest of the documentation details each of the object methods.
       Internal methods are usually preceded with a _

   new
	Title	: new
	Usage	: my $obj = Bio::Tools::Run::StandAloneBlast->new();
	Function: Builds a newBio::Tools::Run::StandAloneBlast object
	Returns : Bio::Tools::Run::StandAloneNCBIBlast or StandAloneWUBlast
	Args	: -quiet => boolean # make program execution quiet
		  -_READMETHOD => 'BLAST' (default, synonym 'SearchIO') || 'blast_pull'
				  # the parsing method, case insensitive

       Essentially all BLAST parameters can be set via StandAloneBlast.pm.
       Some of the most commonly used parameters are listed below. All
       parameters have defaults and are optional except for -p in those
       programs that have it. For a complete listing of settable parameters,
       run the relevant executable BLAST program with the option "-" as in
       blastall - Note that the input paramters (-i, -j, -input) should not be
       set directly by you: this module sets them when you call one of the
       executable methods.

       Blastall

	 -p  Program Name [String]
	       Input should be one of "blastp", "blastn", "blastx",
	       "tblastn", or "tblastx".
	 -d  Database [String] default = nr
	       The database specified must first be formatted with formatdb.
	       Multiple database names (bracketed by quotations) will be accepted.
	       An example would be -d "nr est"
	 -e  Expectation value (E) [Real] default = 10.0
	 -o  BLAST report Output File [File Out]  Optional,
		   default = ./blastreport.out ; set by StandAloneBlast.pm
	 -S  Query strands to search against database (for blast[nx], and tblastx). 3 is both, 1 is top, 2 is bottom [Integer]
		   default = 3

       Blastpgp (including Psiblast)

	 -j  is the maximum number of rounds (default 1; i.e., regular BLAST)
	 -h  is the e-value threshold for including sequences in the
		   score matrix model (default 0.001)
	 -c  is the "constant" used in the pseudocount formula specified in the paper (default 10)
	 -B  Multiple alignment file for PSI-BLAST "jump start mode"  Optional
	 -Q  Output File for PSI-BLAST Matrix in ASCII [File Out]  Optional

       rpsblast

	 -d  Database [String] default = (none - you must specify a database)
	       The database specified must first be formatted with formatdb.
	       Multiple database names (bracketed by quotations) will be accepted.
	       An example would be -d "Cog Smart"
	 -e  Expectation value (E) [Real] default = 10.0
	 -o  BLAST report Output File [File Out]  Optional,
		   default = ./blastreport.out ; set by StandAloneBlast.pm

       Bl2seq

	 -p  Program name: blastp, blastn, blastx. For blastx 1st argument should be nucleotide [String]
	   default = blastp
	 -o  alignment output file [File Out] default = stdout
	 -e  Expectation value (E) [Real]  default = 10.0
	 -S  Query strands to search against database (blastn only).  3 is both, 1 is top, 2 is bottom [Integer]
	   default = 3

       WU-Blast

	 -p Program Name [String]
	       Input should be one of "wublastp", "wublastn", "wublastx",
	       "wutblastn", or "wutblastx".
	 -d  Database [String] default = nr
	       The database specified must first be formatted with xdformat.
	 -E  Expectation value (E) [Real] default = 10.0
	 -o  BLAST report Output File [File Out]  Optional,
		   default = ./blastreport.out ; set by StandAloneBlast.pm

   executable
	Title	: executable
	Usage	: my $exe = $blastfactory->executable('blastall');
	Function: Finds the full path to the executable
	Returns : string representing the full path to the exe
	Args	: [optional] name of executable to set path to
		  [optional] boolean flag whether or not warn when exe is not found

   program_dir
	Title	: program_dir
	Usage	: my $dir = $factory->program_dir();
	Function: Abstract get method for dir of program.
	Returns : string representing program directory
	Args	: none

   _setinput
	Title	:  _setinput
	Usage	:  Internal function, not to be called directly
	Function:   Create input file(s) for Blast executable
	Example :
	Returns : name of file containing Blast data input
	Args	: Seq object reference or input file name

Bio::Tools::Run::WrapperBase methods
   no_param_checks
	Title	: no_param_checks
	Usage	: $obj->no_param_checks($newval)
	Function: Boolean flag as to whether or not we should
		  trust the sanity checks for parameter values
	Returns : value of no_param_checks
	Args	: newvalue (optional)

   save_tempfiles
	Title	: save_tempfiles
	Usage	: $obj->save_tempfiles($newval)
	Function:
	Returns : value of save_tempfiles
	Args	: newvalue (optional)

   outfile_name
	Title	: outfile_name
	Usage	: my $outfile = $tcoffee->outfile_name();
	Function: Get/Set the name of the output file for this run
		  (if you wanted to do something special)
	Returns : string
	Args	: [optional] string to set value to

   tempdir
	Title	: tempdir
	Usage	: my $tmpdir = $self->tempdir();
	Function: Retrieve a temporary directory name (which is created)
	Returns : string which is the name of the temporary directory
	Args	: none

   cleanup
	Title	: cleanup
	Usage	: $tcoffee->cleanup();
	Function: Will cleanup the tempdir directory after a PAML run
	Returns : none
	Args	: none

   io
	Title	: io
	Usage	: $obj->io($newval)
	Function:  Gets a Bio::Root::IO object
	Returns : Bio::Root::IO
	Args	: none

perl v5.14.1			  2011-07-2Bio::Tools::Run::StandAloneBlast(3)
[top]

List of man pages available for Fedora

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net