Free bio tools run tribemcl software for linux

Bio::Tools::Run::TribeMCL is a method for clustering proteins into related groups, which are termed protein families.
SYNOPSIS
use Bio::Tools::Run::TribeMCL;
use Bio::SearchIO;
# 3 methods to input the blast results
# straight forward raw blast output (NCBI or WU-BLAST)
my @params = (inputtype=>blastfile);
# OR
# markov program format
# protein_id1 protein_id2 evalue_magnitude evalue_factor
# for example:
# proteins ENSP00000257547 and ENSP00000261659
# with a blast score evalue of 1e-50
# and proteins O42187 and ENSP00000257547
# with a blast score evalue of 1e-119
# entry would be
my @array = [[qw(ENSP00000257547 ENSP00000261659 1 50)],
[qw(O42187 ENSP00000257547 1 119)]];
my @params = (pairs=>@array,I=>2.0);
# OR
# pass in a searchio object
# slowest of the 3 methods as it does more rigourous parsing
# than required for us here
my $sio = Bio::SearchIO->new(-format=>blast,
-file=>blast.out);
my @params=(inputtype=>searchio,I=>2.0);
# you can specify the path to the executable manually in the following way
my @params=(inputtype=>blastfile,I=>2.0,
mcl=>/home/shawn/software/mcl-02-150/src/shmcl/mcl,
matrix=>/home/shawn/software/mcl-02-150/src/contrib/tribe/tribe-matrix);
my $fact = Bio::Tools::Run::TribeMCL->new(@params);
# OR
$fact->matrix_executable(/home/shawn/software/mcl-02-150/src/contrib/tribe/tribe-matrix);
$fact->mcl_executable(/home/shawn/software/mcl-02-150/src/shmcl/mcl);
# to run
my $fact = Bio::Tools::Run::TribeMCL->new(@params);
# Run the program
# returns an array reference to clusters where members are the ids
# for example :2 clusters with 3 members per cluster:
# $fam = [ [mem1 mem2 mem3],[mem1 mem2 mem3]]
# pass in either the blastfile path/searchio obj/the array ref to scores
my $fam = $fact->run($sio);
# print out your clusters
for (my $i = 0; $i
print "Cluster $i t ".scalar(@{$fam->[$i]})." membersn";
foreach my $member (@{$fam->[$i]}){
print "t$membern";
}
}
This clustering is achieved by analysing similarity patterns between proteins in a given dataset, and using these patterns to assign proteins into related groups. In many cases, proteins in the same protein family will have similar functional properties.
Enhancements:
- Perl

Bio::Tools::Run::JavaRunner is a Perl module that can run java programs.

SYNOPSIS

my $runner = Bio::Tools::Run::JavaRunner->new(-jar => $jar);
$runner->run();

This module is probably incomplete. It is intended to be a wrapper for running java programs.

Bio::Tools::Run::PiseApplication::charge is a Perl module.

Bio::Tools::Run::PiseApplication::charge
Bioperl class for:

CHARGE Protein charge plot (EMBOSS)


Parameters:

(see also:
http://bioweb.pasteur.fr/seqanal/interfaces/charge.html
for available values):


charge (String)

init (String)

seqall (Sequence)
seqall -- protein [sequences] (-seqall)
pipe: seqsfile

window (Integer)
Window (-window)

aadata (String)
Amino acid property data file name (-aadata)

plot (Switch)
Produce graphic (-plot)

graph (Excl)
graph (-graph)

outfile (OutFile)
outfile (-outfile)

auto (String)

psouput (String)

Bio::Root::Object is a core Perl 5 object.

SYNOPSIS

# Use this module as the root of your inheritance tree.
Object Creation
require Bio::Root::Object;

$dad = new Bio::Root::Object();
$son = new Bio::Root::Object(-name => Junior,
-parent => $dad,
-make => full);
See the new() method for a complete description of parameters. See also the USAGE section .

Bio::Root::Object attempts to encapsulate the "core" Perl5 object: What are the key data and behaviors ALL (or at least most) Perl5 objects should have?
Rationale

Use of Bio::Root::Object.pm within the Bioperl framework facilitates operational consistency across the different modules defined within the Bio:: namespace. Not all objects need to derive from Bio::Root::Object.pm. However, when generating lots of different types of potentially complex objects which should all conform to a set of basic expectations, this module may be handy.

At the very least, this module saves you from re-writing the new() method for each module you develop. It also permits consistent and robust handling of -tag => value method arguments via the Bio::Root::RootI::_rearrange() method and provides a object-oriented way handle exceptions and warnings via the Bio::Root::Root::throw() and Bio::Root::Root::warn() methods.

See the APPENDIX section for some other handy methods.

Fault-Tolerant Objects

A major motivation for this module was to promote the creation of robust, fault-tolerant Perl5 objects. The Bio::Root::Root::throw() method relies on Perls built-in eval{}/die exception mechanism to generate fatal exceptions. The data comprising an exception is managed by the Bio::Root::Err.pm module, which essentially allows the data thrown by a die() event to be wrapped into an object that can be easily examined and possibly re-thrown.

The intent here is three-fold:

1 Detailed error reporting.
Allow objects to report detailed information about the error condition (who, what, where, why, how).
2 Handle complex errors in objects.
The goal is to make it relatively painless to detect and handle the wide variety of errors possible with a complex Perl object. Perls error handling mechanism is a might clunky when it comes to handling complex errors within complex objects, but it is improving.
3 Efficient & easy exception handling.
To enable robust exception handling without incurring a significant performance penalty in the resulting code. Ideally, exception handling code should be transparent to the cpu until and unless an exception arises.

These goals may at times be at odds and we are not claiming to have achieved the perfect balance. Ultimately, we want self- sufficient object-oriented systems able to deal with their own errors. This area should improve as the module, and Perl, evolve. One possible modification might be to utilize Graham Barrs Error.pm module or Torsten Ekedahls Experimental::Exception.pm module (see "Other Exception Modules").

Technologies such as these may eventually be incorporated into future releases of Perl. The exception handling used by Bio::Root::Object.pm can be expected to change as Perls exception handling mechanism evolves.

TERMINOLOGY NOTE: In this discussion and elsewhere in this module, the terms "Exception" and "Error" are used interchangeably to mean "something unexpected occurred" either as a result of incorrect user input or faulty internal processing.

Bio::Tools::Run::PiseApplication::consensus is a Perl module.

Bioperl class for:

CONSENSUS Identification of consensus patterns in unaligned DNA and protein sequences (Hertz, Stormo)

References:

G.Z. Hertz and G.D. Stormo. Identification of consensus patterns in unaligned DNA and protein sequences: a large-deviation statistical basis for penalizing gaps. In: Proceedings of the Third International Conference on Bioinformatics and Genome Research (H.A. Lim, and C.R. Cantor, editors). World Scientific Publishing Co., Ltd. Singapore, 1995. pages 201--216.

Parameters:

(see also:
http://bioweb.pasteur.fr/seqanal/interfaces/consensus.html
for available values):


consensus (Excl)
Program to run

sequence (Sequence)
Sequences file (-f)
pipe: seqsfile

width (Integer)
Width of pattern (consensus only) (-L)

out (String)

consensus_matrix (String)

complement (Excl)
Complement of nucleic acid sequences (-c)

ascii_alphabet (InFile)
Alphabet and normalization information (if not DNA) (-a)

prior (Switch)
Use the designated prior probabilities of the letters to override the observed frequencies (-d)

dna (Switch)
Alphabet and normalization information for DNA

protein (Switch)
Alphabet and normalization information for protein

queue (Integer)
Maximum number of matrices to save between cycles of the program -- ie: queue size (-q)

standard_deviation (Float)
Number of standard deviations to lower the information content at each position before identifying information peaks (mandatory for wconsensus) (-s)

progeny (Excl)
Save the top progeny matrices (-pr1)

linearly (Switch)
Seed with the first sequence and proceed linearly through the list (-l)

max_cycle_nb (Integer)
Maximum repeat of the matrix building cycle (-n or -N)

max_cycle (Excl)
How many words per matrix for each sequence to contribute (-n or -N)

distance (Integer)
Minimum distance between the starting points of words within the same matrix pattern (-m)

terminate (Integer)
Terminate the program this number of cycles after the current most significant alignment is identified (-t)

terminal_gap (Excl)
Permit terminal gaps (-pg) (wconsensus only)

top_matrices (Integer)
Number of top matrices to print (-pt)

final_matrices (Integer)
Number of final matrices to print (-pf)

Bio::Ontology::GOterm is a representation of GO terms.

SYNOPSIS

$term = Bio::Ontology::GOterm->new
( -go_id => "GO:0016847",
-name => "1-aminocyclopropane-1-carboxylate synthase",
-definition => "Catalysis of ...",
-is_obsolete => 0,
-comment => "" );

$term->add_definition_references( @refs );
$term->add_secondary_GO_ids( @ids );
$term->add_aliases( @aliases );

foreach my $dr ( $term->each_definition_reference() ) {
print $dr, "n";
}

# etc.

This is "dumb" class for GO terms (it provides no functionality related to graphs). Implements Bio::Ontology::TermI.

Bio::NEXUS::MatrixBlock is a Perl module that provides functions for handling blocks that have matrices.

SYNOPSIS

This module is the super class of Characters, Unaligned, and Distances block classes, and indirectly it is a super-class of Data and History blocks, which are both sub-classes of Characters blocks. These sub-classes inherint the methods within this module. There is no constructor, as a MatrixBlock should not exist that is not also one of the sub-class block types.

Provides functions used for handling blocks that have matrices.

METHODS

get_ntax

Title : get_ntax
Usage : $block->get_ntax();
Function: Returns the number of taxa in the block
Returns : # taxa
Args : none

get_nchar

Title : get_nchar
Usage : $block->get_nchar();
Function: Returns the number of characters in the block (Note: In Distances Blocks, this is the number of characters used to infer distances.)
Returns : # taxa
Args : none

set_format

Title : set_format
Usage : $block->set_format(%format);
Function: set the format of the characters
Returns : none
Args : hash of format values

get_format

Title : get_format
Usage : $block->get_format($attribute);
Function: Returns the format of the characters
Returns : hash of format values, or if $attribute (a string) is supplied, the value of that attribute in the hash
Args : none

add_taxlabels

Title : add_taxlabels
Usage : $block->add_taxlabels($new_taxlabels);
Function: Adds new taxa to taxlabels if they arent already there
Returns : none
Args : taxa to be added

Bio::Location::CoordinatePolicyI is an abstract interface for objects implementing a certain policy of computing integer-valued coordinates of a Location.

SYNOPSIS

# get a location, e.g., from a SeqFeature
$location = $feature->location();
# examine its coordinate computation policy
print "Location of feature ", $feature->primary_tag(), " employs a ",
ref($location->coordinate_policy()),
" instance for coordinate computationn";
# change the policy, e.g. because the user chose to do so
$location->coordinate_policy(Bio::Location::NarrowestCoordPolicy->new());

Objects implementing this interface are used by Bio::LocationI implementing objects to determine integer-valued coordinates when asked for it. While this may seem trivial for simple locations, there are different ways to do it for fuzzy or compound (split) locations. Classes implementing this interface implement a certain policy, like always widest range, always smallest range, mean for BETWEEN locations, etc. By installing a different policy object in a Location object, the behaviour of coordinate computation can be changed on-the-fly, and with a single line of code client-side.