Bio::Tools::Run::Phylo::Phylip::Consense(3pm)

NAME

Bio::Tools::Run::Phylo::Phylip::Consense - Wrapper for the phylip program Consense

SYNOPSIS

  use Bio::Tools::Run::Phylo::Phylip::Consense;
  use Bio::Tools::Run::Phylo::Phylip::SeqBoot;
  use Bio::Tools::Run::Phylo::Phylip::ProtDist;
  use Bio::Tools::Run::Phylo::Phylip::Neighbor;
  use Bio::Tools::Run::Phylo::Phylip::DrawTree;
  #first get an alignment
  my $aio= Bio::AlignIO->new(-file=>$ARGV[0],-format=>"clustalw");
  my $aln = $aio->next_aln;
  # To prevent truncation of sequence names by PHYLIP runs, use set_displayname_safe
  my ($aln_safe, $ref_name)=$aln->set_displayname_safe();
  #next use seqboot to generate multiple aligments
  my @params = ('datatype'=>'SEQUENCE','replicates'=>10);
  my $seqboot_factory = Bio::Tools::Run::Phylo::Phylip::SeqBoot->new(@params);
  my $aln_ref= $seqboot_factory->run($aln);
  Or, for long sequence names:
  my $aln_ref= $seqboot_factory->run($aln_safe);
  #next build distance matrices and construct trees
  my $pd_factory = Bio::Tools::Run::Phylo::Phylip::ProtDist->new();
  my $ne_factory = Bio::Tools::Run::Phylo::Phylip::Neighbor->new();
  foreach my $a (@{$aln_ref}){
    my $mat = $pd_factory->create_distance_matrix($a);
    push @tree, $ne_factory->create_tree($mat);
  }
  #now use consense to get a final tree
  my $con_factory = Bio::Tools::Run::Phylo::Phylip::Consense->new();
  #you may set outgroup either by the number representing the order in
  #which species are entered or by the name of the species
  $con_factory->outgroup(1);
  $con_factory->outgroup('HUMAN');
  my $tree = $con_factory->run(\@tree);
  # Restore original sequence names, after ALL phylip runs:
  my @nodes = $tree->get_nodes();
  foreach my $nd (@nodes){
     $nd->id($ref_name->{$nd->id_output}) if $nd->is_Leaf;
  }
  #now draw the tree
  my $draw_factory = Bio::Tools::Run::Phylo::Phylip::DrawTree->new();
  my $image_filename = $draw_factory->draw_tree($tree);

DESCRIPTION

Wrapper for phylip consense program

Taken from phylip documentation...

CONSENSE reads a file of computer-readable trees and prints out (and may also write out onto a file) a consensus tree. At the moment it carries out a family of consensus tree methods called the M[l] methods (Margush and McMorris, 1981). These include strict consensus and majority rule consensus. Basically the consensus tree consists of monophyletic groups that occur as often as possible in the data.

More documentation on using Consense and setting parameters may be found in the phylip package.

VERSION Support

This wrapper currently supports v3.5 of phylip. There is also support for v3.6 although this is still experimental as v3.6 is still under alpha release and not all functionalities maybe supported.

PARAMETERS FOR Consense

TYPE

Title : TYPE Description : (optional)
Only available in phylip v3.6

                  This program supports 3 types of consensus generation 
                  MRe   : Majority Rule (extended) Any set of species that
                          appears in more than 50% of the trees is included. 
                          The program then considers the other sets of species 
                          in order of the frequency with which they have appeared, 
                          adding to the consensus tree any which are compatible 
                          with it until
                  STRICT: A set of species must appear in all input trees to be 
                          included in the strict consensus tree. 
                  MR    :  A set of species is included in the consensus tree 
                          if it is present in more than half of the input trees. 
                  Ml    : The user is asked for a fraction between 0.5 and 1, and 
                          the program then includes in the consensus tree any set 
                          of species that occurs among the input trees more than 
                          that fraction of then time. The Strict consensus and the 
                          Majority Rule consensus are extreme cases of the M[l] consensus,
                          being for fractions of 1 and 0.5 respectively
                  usage: my $factory = Bio::Tools::Run::Phylo::Phylip::Consense->new(-type=>"Ml 0.7");
             Defaults to MRe

ROOTED

  Title: ROOTED 
  Description: (optional)
             toggles between the default assumption that the input trees are unrooted trees and 
             the selection that specifies that the tree is to be treated as a rooted tree and not 
             re-rooted. Otherwise the tree will be treated as outgroup-rooted and will be
             re-rooted automatically at the first species encountered on the first tree 
             (or at a species designated by the Outgroup option)
             usage: my $factory = Bio::Tools::Run::Phylo::Phylip::Consense->new(-rooted=>1);
             Defaults to unrooted

OUTGROUP

  Title         : OUTGROUP
  Description   : (optional)
                It is in effect only if the Rooted option selection is not in effect.
                The trees will be re-rooted with a species of your choosing.
                usage  my $factory = Bio::Tools::Run::Phylo::Phylip::Consense->new(-outgroup=>2);
                Defaults to first species encountered.

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.

  [email protected]                  - General discussion
  http://bioperl.org/wiki/Mailing_lists  - About the mailing lists

Support

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

[email protected]

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://redmine.open-bio.org/projects/bioperl/

AUTHOR - Shawn Hoon

Email [email protected]

APPENDIX

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

program_name

 Title   : program_name
 Usage   : $obj->program_name()
 Function: holds the program name
 Returns:  string
 Args    : None

program_dir

 Title   : program_dir
 Usage   : ->program_dir()
 Function: returns the program directory, obtained from ENV variable.
 Returns:  string
 Args    :

idlength

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

run

 Title   : run 
 Usage   :
        $inputfilename = 't/data/prot.treefile';
        $tree= $Consense_factory->run($inputfilename);
or
        $tree= $consense_factory->run(\@tree);
 Function: Create bootstrap sets of alignments
 Example :
 Returns : a L<Bio::Tree::Tree>
 Args    : either a file containing trees in newick format
           or an array ref of L<Bio::Tree::Tree>
 Throws an exception if argument is not either a string (eg a
 filename) or a Bio::Tree::TreeI object. If
 argument is string, throws exception if file corresponding to string
 name can not be found.

_run

 Title   :  _run
 Usage   :  Internal function, not to be called directly        
 Function:  makes actual system call to Consense program
 Example :
 Returns : an array ref of <Bio::Tree::Tree> 
 Args    : Name of a file containing a set of tree in newick format 
           and a parameter string to be passed to Consense

_setinput()

 Title   :  _setinput
 Usage   :  Internal function, not to be called directly        
 Function:   Create input file for Consense program
 Example :
 Returns : name of file containing a trees in newick format
 Args    : an array ref of Bio::Tree::Tree object or input file name

names()

 Title   :  names
 Usage   :  $tree->names(\%names)
 Function:  get/set for a hash ref for storing names in matrix
            with rank as values.
 Example :
 Returns : hash reference
 Args    : hash reference

_setparams()

 Title   :  _setparams
 Usage   :  Internal function, not to be called directly        
 Function:   Create parameter inputs for Consense program
 Example :
 Returns : parameter string to be passed to Consense
 Args    : name of calling object

Bio::Tools::Run::Wrapper 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 = $Consense->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   : $codeml->cleanup();
 Function: Will cleanup the tempdir directory after a Consense run
 Returns : none
 Args    : none

io

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