Free bio tools run tribemcl 1.4 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::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::freak is a Perl module.

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

FREAK Residue/base frequency table or plot (EMBOSS)


Parameters:

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


freak (String)

init (String)

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

letters (String)
Residue letters (-letters)

step (Integer)
Stepping value (-step)

window (Integer)
Averaging window (-window)

plot (Switch)
Produce graphic (-plot)

graph (Excl)
graph (-graph)

outfile (OutFile)
outfile (-outfile)

auto (String)

psouput (String)

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::Tools::Run::PiseApplication::align2model is a Bioperl class for align2model - create a multiple alignment of sequences to an existing model.

Parameters:

align2model (String)

run (String)
Run name

db (Sequence)
Sequences to align (-db)

model_file (InFile)
Model (-i)
pipe: sam_model

id (String)
Sequence identifier(s) selection (separated by commas) (-id)

nscoreseq (Integer)
Maximum number of sequences to be read (-nscoreseq)

adpstyle (Excl)
Dynamic programming style (-adpstyle

SW (Excl)
Sequence scoring (-SW)

auto_fim (Switch)
Add FIMs automatically (-auto_fim)

jump_in_prob (Float)
Probability cost of jumping into the center of the model (-jump_in_prob)

jump_out_prob (Float)
Probability cost of jumping out the center of the model (-jump_out_prob)

a2mdots (Switch)
Print dots to fill space need for other sequences insertions (-a2mdots)

dump_parameters (Excl)
(-dump_parameters)

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::Tools::AlignFactory is a base object for alignment factories.

SYNOPSIS

You wont be using this as an object, but using a dervied class like Bio::Tools::pSW

Holds common Alignment Factory attributes in place

Bio::Ontology::Relationship is a relationship for an ontology.

SYNOPSIS

$rel = Bio::Ontology::Relationship->new( -identifier => "16847",
-subject_term => $subj,
-object_term => $obj,
-predicate_term => $pred );

This is a basic implementation of Bio::Ontology::RelationshipI.

The terminology we use here is the one commonly used for ontologies, namely the triple of (subject, predicate, object), which in addition is scoped in a namespace (ontology). It is called triple because it is a tuple of three ontology terms.

There are other terminologies in use for expressing relationships. For those who it helps to better understand the concept, the triple of (child, relationship type, parent) would be equivalent to the terminology chosen here, disregarding the question whether the notion of parent and child is sensible in the context of the relationship type or not. Especially in the case of ontologies with a wide variety of predicates the parent/child terminology and similar ones can quickly become ambiguous (e.g., A synthesises B), meaningless (e.g., A binds B), or even conflicting (e.g., A is-parent-of B), and are therefore strongly discouraged.