View on
MetaCPAN is shutting down
For details read Perl NOC. After June 25th this page will redirect to
Christopher Fields > BioPerl-Run-1.006900 > Bio::Tools::Run::StandAloneBlastPlus



Annotate this POD


Open  2
View/Report Bugs
Source   Latest Release: BioPerl-Run-1.007002


Bio::Tools::Run::StandAloneBlastPlus - Compute with NCBI's blast+ suite *ALPHA*


NOTE: This module is related to the Bio::Tools::Run::StandAloneBlast system in name (and inspiration) only. You must use this module directly.

 # existing blastdb:
 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
   -db_name => 'mydb'
 # create blastdb from fasta file and attach
 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
   -db_name => 'mydb',
   -db_data => 'myseqs.fas',
   -create => 1
 # create blastdb from BioPerl sequence collection objects
 $alnio = Bio::AlignIO->new( -file => 'alignment.msf' );
 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
   -db_name => 'mydb',
   -db_data => $alnio,
   -create => 1

 @seqs = $alnio->next_aln->each_seq;
 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
   -db_name => 'mydb',
   -db_data => \@seqs,
   -create => 1

 # create database with masks

 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
  -db_name => 'my_masked_db',
  -db_data => 'myseqs.fas',
  -masker => 'dustmasker',
  -mask_data => 'maskseqs.fas',
  -create => 1

 # create a mask datafile separately
 $mask_file = $fac->make_mask(
   -data => 'maskseqs.fas',
   -masker => 'dustmasker'

 # query database for metadata
 $info_hash = $fac->db_info;
 $num_seq = $fac->db_num_sequences;
 @mask_metadata = @{ $fac->db_filter_algorithms };

 # perform blast methods
 $result = $fac->tblastn( -query => $seqio );
 # see Bio::Tools::Run::StandAloneBlastPlus::BlastMethods 
 # for many more details


NOTE: This module requires BLAST+ v. 2.2.24+ and higher. Until the API stabilizes for BLAST+, consider this module highly experimental.

This module along with Bio::Tools::Run::StandAloneBlastPlus::BlastMethods allows the user to perform BLAST functions using the external program suite blast+ (available at, using BioPerl objects and Bio::SearchIO facilities. This wrapper can prepare BLAST databases as well as run BLAST searches. It can also be used to run blast+ programs independently.

This module encapsulates object construction and production of databases and masks. Blast analysis methods (blastp, psiblast, etc>) are contained in Bio::Tools::Run::StandAloneBlastPlus::BlastMethods.


The basic mantra is to (1) create a BlastPlus factory using the new() constructor, and (2) perform BLAST analyses by calling the desired BLAST program by name off the factory object. The blast database itself and any masking data are attached to the factory object (step 1). Query sequences and any parameters associated with particular programs are provided to the blast method call (step 2), and are run against the attached database.

Factory construction/initialization

The factory needs to be told where the blast+ programs live. The BLASTPLUSDIR environment variable will be checked for the default executable directory. The program directory can be set for individual factory instances with the PROG_DIR parameter. All the blast+ programs must be accessible from that directory (i.e., as executable files or symlinks).

Either the database or BLAST subject data must be specified at object construction. Databases can be pre-existing formatted BLAST dbs, or can be built directly from fasta sequence files or BioPerl sequence object collections of several kinds. The key constructor parameters are DB_NAME, DB_DATA, DB_DIR.

To specify a pre-existing BLAST database, use DB_NAME alone:

 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
     -DB_NAME => 'mydb'

The directory can be specified along with the basename, or separately with DB_DIR:

 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
     -DB_NAME => '~/home/blast/mydb'

 #same as

 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
     -DB_NAME => 'mydb', -DB_DIR => '~/home/blast'

To create a BLAST database de novo, see "Creating a BLAST database".

If you wish to apply pre-existing mask data (i.e., the final ASN1 output from one of the blast+ masker programs), to the database before querying, specify it with MASK_FILE:

 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
     -DB_NAME => 'mydb', -MASK_FILE => 'mymaskdata.asn'

Creating a BLAST database

There are several options for creating the database de novo using attached data, both before and after factory construction. If a temporary database (one that can be deleted by the cleanup() method) is desired, leave out the -db_name parameter. If -db_name is specified, the database will be preserved with the basename specified.

Use -create = 1> to create a new database (otherwise the factory will look for an existing database). Use -overwrite = 1> to create and overwrite an existing database.

Note that the database is not created immediately on factory construction. It will be created if necessary on the first use of a factory BLAST method, or you can force database creation by executing


Creating and using mask data

The blast+ mask utilities windowmasker, segmasker, and dustmasker are available. Masking can be rolled into database creation, or can be executed later. If your mask data is already created and in ASN1 format, set the -mask_file attribute on construction (see "Factory constuction/initialization").

To create a mask from raw data or an existing database and apply the mask upon database creation, construct the factory like so:

 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
   -db_name => 'my_masked_db',
   -db_data => 'myseqs.fas',
   -masker => 'dustmasker',
   -mask_data => 'maskseqs.fas',
   -create => 1

The masked database will be created during make_db.

The -mask_data parameter can be a FASTA filename or any BioPerl sequence object collection. If the datatype ('nucl' or 'prot') of the mask data is not compatible with the selected masker, an exception will be thrown with a message to that effect.

To create a mask ASN1 file that can be used in the -mask_file parameter separately from the attached database, use the make_mask() method directly:

 $mask_file = $fac->make_mask(-data => 'maskseqs.fas',
                              -masker => 'dustmasker');
 # segmasker can use a blastdb as input
 $mask_file = $fac->make_mask(-mask_db => 'mydb',
                              -masker => 'segmasker')

 $fac = Bio::Tools::Run::StandAloneBlastPlus->new(
   -db_name => 'my_masked_db',
   -db_data => 'myseqs.fas',
   -mask_file => $mask_file
   -create => 1

Getting database information

To get a hash containing useful metadata on an existing database (obtained by running blastdbcmd -info, use db_info():

 # get info on the attached database..
 $info = $fac->db_info;
 # get info on another database
 $info = $fac->db_info('~/home/blastdbs/another');

To get a particular info element for the attached database, just call the element name off the factory:

 $num_seqs = $fac->db_num_sequences;
 # info on all the masks applied to the db, if any:
 @masking_info = @{ $fac->db_filter_algorithms };

Accessing the Bio::Tools::Run::BlastPlus factory

The blast+ programs are actually executed by a Bio::Tools::Run::BlastPlus wrapper instance. This instance is available for peeking and poking in the StandAloneBlastPlus factory() attribute. For convenience, BlastPlus methods can be run from the StandAloneBlastPlus object, and are delegated to the factory() attribute. For example, to get the blast+ program to be executed, examine either




Similarly, the current parameters for the BlastPlus factory are

 @parameters = $fac->get_parameters

Cleaning up temp files

Temporary analysis files produced under a single factory instances can be unlinked by running


Tempfiles are generally not removed unless this method is explicitly called. cleanup() only unlinks "registered" files and databases. All temporary files are automatically registered; in particular, "anonymous" databases (such as

   -db_data => 'myseqs.fas', 
   -create => 1

without a -db_name specification) are registered for cleanup. Any file or database can be registered with an internal method:


Other Goodies


Bio::Tools::Run::StandAloneBlastPlus::BlastMethods, Bio::Tools::Run::BlastPlus


Mailing Lists

User feedback is an integral part of the evolution of this and other Bioperl modules. Send your comments and suggestions preferably to the Bioperl mailing list. Your participation is much appreciated.                  - General discussion  - About the mailing lists


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

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 of the bugs and their resolution. Bug reports can be submitted via the web:

AUTHOR - Mark A. Jensen ^

Email maj -at- fortinbras -dot- us



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


 Title   : new
 Usage   : my $obj = new Bio::Tools::Run::StandAloneBlastPlus();
 Function: Builds a new Bio::Tools::Run::StandAloneBlastPlus object
 Returns : an instance of Bio::Tools::Run::StandAloneBlastPlus
 Args    : named argument (key => value) pairs:
           -db : blastdb name


 Title   : db
 Usage   : $obj->db($newval)
 Function: contains the basename of the local blast database
 Example : 
 Returns : value of db (a scalar string)
 Args    : readonly


 Title   : factory
 Usage   : $obj->factory($newval)
 Function: attribute containing the Bio::Tools::Run::BlastPlus 
 Example : 
 Returns : value of factory (Bio::Tools::Run::BlastPlus object)
 Args    : readonly


 Title   : program_version
 Usage   : $version = $bedtools_fac->program_version()
 Function: Returns the program version (if available)
 Returns : string representing location and version of the program
 Note    : this works around the WrapperBase::version() method conflicting with
           the -version parameter for SABlast (good argument for not having
           getter/setters for these)


 Title   : package_version
 Usage   : $version = $bedtools_fac->package_version()
 Function: Returns the BLAST+ package version (if available)
 Returns : string representing BLAST+ package version (may differ from version())

DB methods ^


 Title   : make_db
 Usage   : 
 Function: create the blast database (if necessary), 
           imposing masking if specified
 Returns : true on success
 Args    : 


 Title   : make_mask
 Usage   : 
 Function: create masking data based on specified parameters
 Returns : mask data filename (scalar string)
 Args    : 


 Title   : db_info
 Usage   : 
 Function: get info for database 
           (via blastdbcmd -info); add factory attributes
 Returns : hash of database attributes
 Args    : [optional] db name (scalar string) (default: currently attached db)


 Title   : set_db_make_args
 Usage   : 
 Function: set the DB make arguments attribute 
           with checking
 Returns : true on success
 Args    : arrayref or hashref of named arguments


 Title   : set_mask_make_args
 Usage   : 
 Function: set the masker make arguments attribute
           with checking
 Returns : true on success
 Args    : arrayref or hasref of named arguments


 Title   : check_db
 Usage   : 
 Function: determine if database with registered name and dir
 Returns : 1 if db present, 0 if not present, undef if name/dir not
 Args    : [optional] db name (default is 'registered' name in $self->db)
           [optional] db directory (default is 'registered' dir in 


 Title   : no_throw_on_crash
 Usage   : $fac->no_throw_on_crash($newval)
 Function: set to prevent an exeception throw on a failed 
           blast program execution
 Example : 
 Returns : value of no_throw_on_crash (boolean)
 Args    : on set, new value (boolean)

Internals ^


 Title   : _fastize
 Usage   : 
 Function: convert a sequence collection to a temporary
           fasta file (sans gaps)
 Returns : fasta filename (scalar string)
 Args    : sequence collection 


 Title   : _register_temp_for_cleanup
 Usage   : 
 Function: register a file for cleanup with 
           cleanup() method
 Returns : true on success
 Args    : a file name or a blastdb basename
           (scalar string)


 Title   : cleanup
 Usage   : 
 Function: unlink files registered for cleanup
 Returns : true on success
 Args    : 


In this module, AUTOLOAD() delegates Bio::Tools::Run::WrapperBase and Bio::Tools::Run::WrapperBase::CommandExts methods (including those of Bio::ParamterBaseI) to the factory() attribute:


gives you


If $AUTOLOAD isn't pointing to a WrapperBase method, then AUTOLOAD attempts to return a db_info attribute: e.g.


works by looking in the $fac->db_info() hash.

Finally, if $AUTOLOAD is pointing to a blast query method, AUTOLOAD runs run with the -method parameter appropriately set.

syntax highlighting: