File Coverage

blib/lib/Bio/Tools/Phylo/PAML/Result.pm

Criterion	Covered	Total	%
statement	221	266	83.0
branch	96	146	65.7
condition	16	50	32.0
subroutine	47	52	90.3
pod	48	48	100.0
total	428	562	76.1

package Bio::Tools::Phylo::PAML::Result;
$Bio::Tools::Phylo::PAML::Result::VERSION = '1.7.2';
use utf8;
use strict;
use warnings;

use base qw(Bio::Root::Root Bio::AnalysisResultI);

# ABSTRACT: A PAML result set object
# AUTHOR: Jason Stajich
# AUTHOR: Aaron Mackey
# OWNER: Jason Stajich
# OWNER: Aaron Mackey
# LICENSE: Perl_5

# AUTHOR: Albert Vilella



sub new {
  my($class,@args) = @_;

  my $self = $class->SUPER::new(@args);
  my ($trees,$mlmat,$seqs,$ngmatrix,
      $codonpos,$codonfreq,$version,
      $model,$patterns, $stats,
      $aafreq, $aadistmat,
      $aamldistmat,
      $ntfreqs, $seqfile, $kappa_mat, $alpha_mat,
      $NSSitesresults,$input_params,$rst,$rst_persite,$rst_trees ) =
      $self->_rearrange([qw
                 (TREES MLMATRIX
                  SEQS NGMATRIX
                  CODONPOS CODONFREQ
                  VERSION MODEL PATTERNS
                  STATS AAFREQ AADISTMAT
                  AAMLDISTMAT
                  NTFREQ SEQFILE
                  KAPPA_DISTMAT
                  ALPHA_DISTMAT
                  NSSITESRESULTS
                  INPUT_PARAMS
                  RST RST_PERSITE RST_TREES)],
                @args);
  $self->reset_seqs;
  if( $trees ) {
      if(ref($trees) !~ /ARRAY/i ) {
      $self->warn("Must provide a valid array reference to initialize trees");
      } else {
      foreach my $t ( @$trees ) {
          $self->add_tree($t);
      }
      }
  }
  $self->{'_treeiterator'} = 0;

  if( $mlmat ) {
      if( ref($mlmat) !~ /ARRAY/i ) {
      $self->warn("Must provide a valid array reference to initialize MLmatrix");
      } else {
      $self->set_MLmatrix($mlmat);
      }
  }
  if( $seqs ) {
      if( ref($seqs) !~ /ARRAY/i ) {
      $self->warn("Must provide a valid array reference to initialize seqs");
      } else {
      foreach my $s ( @$seqs ) {
          $self->add_seq($s);
      }
      }
  }
  if( $ngmatrix ) {
      if( ref($ngmatrix) !~ /ARRAY/i ) {
      $self->warn("Must provide a valid array reference to initialize NGmatrix");
      } else {
      $self->set_NGmatrix($ngmatrix);
      }
  }
  if( $codonfreq ) {
      if( ref($codonfreq) =~ /ARRAY/i ) {
      $self->set_CodonFreqs($codonfreq);
      } else {
      $self->warn("Must provide a valid array reference to initialize codonfreq");
      }
  }

  if( $codonpos ) {
      if( ref($codonpos) !~ /ARRAY/i ) {
      $self->warn("Must provide a valid array reference to initialize codonpos");
      } else {
      $self->set_codon_pos_basefreq(@$codonpos);
      }
  }

  $self->version($version)   if defined $version;
  $self->seqfile($seqfile)   if defined $seqfile;
  $self->model($model)       if defined $model;
  if( defined $patterns ) {
      if( ref($patterns) =~ /HASH/i ) {
      $self->patterns($patterns);
      } else {
      $self->warn("Must provide a valid array reference to initialize patterns");
      }
  }

  $self->{'_aafreqs'} = {};
  if( $aafreq ) {
      if( ref($aafreq) =~ /HASH/i ) {
      $self->set_AAFreqs($aafreq);
      } else {
      $self->warn("Must provide a valid hash reference to initialize aafreq");
      }
  }
  if( $stats ) {
      if( ref($stats) =~ /HASH/i ) {
      while( my ($stat,$val) = each %$stats) {
          $self->add_stat($stat,$val);
      }
      } else {
      $self->warn("Must provide a valid hash reference initialize stats");
      }
  }
  $self->set_AADistMatrix($aadistmat) if defined $aadistmat;
  $self->set_AAMLDistMatrix($aamldistmat) if defined $aamldistmat;

  if( defined $NSSitesresults ) {
      if( ref($NSSitesresults) !~ /ARRAY/i ) {
      $self->warn("expected an arrayref for -NSSitesresults");
      } else {
      foreach my $m ( @$NSSitesresults ) {
          $self->add_NSSite_result($m);
      }
      }
  }

  $self->{'_ntfreqs'} = {};
  if( $ntfreqs ) {
      if( ref($ntfreqs) =~ /HASH/i ) {
      $self->set_NTFreqs($ntfreqs);
      } else {
      $self->warn("Must provide a valid hash reference to initialize ntfreq");
      }
  }

  if( $kappa_mat ) {
      $self->set_KappaMatrix($kappa_mat);
  }
  if( $alpha_mat ) {
      $self->set_AlphaMatrix($alpha_mat);
  }

  if( $input_params ) {
      if(  ref($input_params) !~ /HASH/i ) {
      $self->warn("Must provide a valid hash object for input_params\n");
      } else {
      while( my ($p,$v) = each %$input_params ) {
          $self->set_input_parameter($p,$v);
      }
      }

  }
  $self->reset_rst_seqs;
  if( $rst ) {
      if( ref($rst) =~ /ARRAY/i ) {
      for ( @$rst ) {
          $self->add_rst_seq($_);
      }
      } else {
      $self->warn("Need a valid array ref for -rst option\n");
      }
  }
  if( defined $rst_persite ) {
      $self->set_rst_persite($rst_persite);
  }
  $self->reset_rst_trees;
  if( $rst_trees ) {
      if( ref($rst_trees) =~ /ARRAY/i ) {
      for ( @$rst_trees ) {
          $self->add_rst_tree($_);
      }
      } else {
      $self->warn("Need a valid array ref for -rst_trees option\n");
      }
  }

  return $self;
}


sub next_tree{
   my ($self,@args) = @_;
   return $self->{'_trees'}->[$self->{'_treeiterator'}++] || undef;
}


sub get_trees{
   my ($self) = @_;
   return @{$self->{'_trees'} || []};
}


sub rewind_tree_iterator {
    shift->{'_treeiterator'} = 0;
}


sub add_tree{
   my ($self,$tree) = @_;
   if( $tree && ref($tree) && $tree->isa('Bio::Tree::TreeI') ) {
       push @{$self->{'_trees'}},$tree;
   }
   return scalar @{$self->{'_trees'}};
}



sub set_MLmatrix{
   my ($self,$mat) = @_;
   return unless ( defined $mat );
   if( ref($mat) !~ /ARRAY/i ) {
       $self->warn("Did not provide a valid 2D Array reference for set_MLmatrix");
       return;
   }
   $self->{'_mlmatrix'} = $mat;
}


sub get_MLmatrix{
   my ($self,@args) = @_;
   return $self->{'_mlmatrix'};
}


sub set_NGmatrix{
   my ($self,$mat) = @_;
   return unless ( defined $mat );
   if( ref($mat) !~ /ARRAY/i ) {
       $self->warn("Did not provide a valid 2D Array reference for set_NGmatrix");
       return;
   }
   $self->{'_ngmatrix'} = $mat;
}


sub get_NGmatrix{
   my ($self,@args) = @_;
   return $self->{'_ngmatrix'};
}



sub add_seq{
   my ($self,$seq) = @_;
   if( $seq ) {
       unless( $seq->isa("Bio::PrimarySeqI") ) {
       $self->warn("Must provide a valid Bio::PrimarySeqI to add_seq");
       return;
       }
       push @{$self->{'_seqs'}},$seq;
   }

}


sub reset_seqs{
   my ($self) = @_;
   $self->{'_seqs'} = [];
}


sub get_seqs{
   my ($self) = @_;
   return @{$self->{'_seqs'}};
}


sub set_codon_pos_basefreq {
    my ($self,@codonpos) = @_;
    if( scalar @codonpos != 3 ) {
    $self->warn("invalid array to set_codon_pos_basefreq, must be an array of length 3");
    return;
    }
    foreach my $pos ( @codonpos ) {
    if( ref($pos) !~ /HASH/i ||
        ! exists $pos->{'A'} ) {
        $self->warn("invalid array to set_codon_pos_basefreq, must be an array with hashreferences keyed on DNA bases, C,A,G,T");
    }
    }
    $self->{'_codonposbasefreq'} = [@codonpos];
}


sub get_codon_pos_basefreq{
   my ($self) = @_;
   return @{$self->{'_codonposbasefreq'}};
}


sub version{
   my $self = shift;
   $self->{'_version'} = shift if @_;
   return $self->{'_version'};
}


sub seqfile{
   my $self = shift;
   $self->{'_seqfile'} = shift if @_;
   return $self->{'_seqfile'};
}


sub model{
    my $self = shift;

    return $self->{'_model'} = shift if @_;
    return $self->{'_model'};
}



sub patterns{
    my $self = shift;
    return $self->{'_patterns'} = shift if @_;
    return $self->{'_patterns'};
}


sub set_AAFreqs{
   my ($self,$aafreqs) = @_;

   if( $aafreqs && ref($aafreqs) =~ /HASH/i ) {
       foreach my $seqname ( keys %{$aafreqs} ) {
       $self->{'_aafreqs'}->{$seqname} = $aafreqs->{$seqname};
       }
   }
}


sub get_AAFreqs{
   my ($self,$seqname) = @_;
   if( $seqname ) {
       return $self->{'_aafreqs'}->{$seqname} || {};
   } else {
       return $self->{'_aafreqs'};
   }
}


sub set_NTFreqs{
   my ($self,$freqs) = @_;

   if( $freqs && ref($freqs) =~ /HASH/i ) {
       foreach my $seqname ( keys %{$freqs} ) {
       $self->{'_ntfreqs'}->{$seqname} = $freqs->{$seqname};
       }
   }
}


sub get_NTFreqs{
   my ($self,$seqname) = @_;
   if( $seqname ) {
       return $self->{'_ntfreqs'}->{$seqname} || {};
   } else {
       return $self->{'_ntfreqs'};
   }
}


sub add_stat{
   my ($self,$stat,$value) = @_;
   return if( ! defined $stat || !defined $value );
   $self->{'_stats'}->{$stat} = $value;
   return;
}


sub get_stat{
   my ($self,$statname) = @_;
   return $self->{'_stats'}->{$statname};
}


sub get_stat_names{
   my ($self) = @_;
   return keys %{$self->{'_stats'} || {}};
}


sub get_AADistMatrix{
    my $self = shift;
    return $self->{'_AADistMatix'};
}


sub set_AADistMatrix{
   my ($self,$d) = @_;
   if( ! $d ||
       ! ref($d) ||
       ! $d->isa('Bio::Matrix::PhylipDist') ) {
       $self->warn("Must provide a valid Bio::Matrix::MatrixI for set_AADistMatrix");
   }
   $self->{'_AADistMatix'} = $d;
   return;
}


sub get_AAMLDistMatrix{
    my $self = shift;
    return $self->{'_AAMLDistMatix'};
}


sub set_AAMLDistMatrix{
   my ($self,$d) = @_;
   if( ! $d ||
       ! ref($d) ||
       ! $d->isa('Bio::Matrix::PhylipDist') ) {
       $self->warn("Must provide a valid Bio::Matrix::MatrixI for set_AAMLDistMatrix");
   }
   $self->{'_AAMLDistMatix'} = $d;
   return;
}


sub add_NSSite_result{
   my ($self,$model) = @_;
   if( defined $model ) {
       push @{$self->{'_nssiteresult'}}, $model;
   }
   return scalar @{$self->{'_nssiteresult'}};
}


sub get_NSSite_results{
   my ($self) = @_;
   return @{$self->{'_nssiteresult'} || []};
}


sub set_CodonFreqs{
    my $self = shift;

    return $self->{'_codonfreqs'} = shift if @_;
    return $self->{'_codonfreqs'};
}


sub get_CodonFreqs{
   my ($self) = @_;
   return @{$self->{'_codonfreqs'} || []};
}



sub get_KappaMatrix{
    my $self = shift;
    return $self->{'_KappaMatix'};
}


sub set_KappaMatrix{
   my ($self,$d) = @_;
   if( ! $d ||
       ! ref($d) ||
       ! $d->isa('Bio::Matrix::PhylipDist') ) {
       $self->warn("Must provide a valid Bio::Matrix::MatrixI for set_NTDistMatrix");
   }
   $self->{'_KappaMatix'} = $d;
   return;
}



sub get_AlphaMatrix{
    my $self = shift;
    return $self->{'_AlphaMatix'};
}


sub set_AlphaMatrix{
   my ($self,$d) = @_;
   if( ! $d ||
       ! ref($d) ||
       ! $d->isa('Bio::Matrix::PhylipDist') ) {
       $self->warn("Must provide a valid Bio::Matrix::MatrixI for set_NTDistMatrix");
   }
   $self->{'_AlphaMatix'} = $d;
   return;
}


sub set_input_parameter{
   my ($self,$p,$v) = @_;
   return unless defined $p;
   $self->{'_input_parameters'}->{$p} = $v;
}


sub get_input_parameters{
   my ($self) = @_;
   return %{$self->{'_input_parameters'} || {}};
}


sub reset_input_parameters{
   my ($self) = @_;
   $self->{'_input_parameters'} = {};
}


sub add_rst_seq{
   my ($self,$seq) = @_;
   if( $seq ) {
       unless( $seq->isa("Bio::PrimarySeqI") ) {
       $self->warn("Must provide a valid Bio::PrimarySeqI to add_rst_seq");
       return;
       }
       push @{$self->{'_rstseqs'}},$seq;
   }

}


sub reset_rst_seqs{
   my ($self) = @_;
   $self->{'_rstseqs'} = [];
}


sub get_rst_seqs{
   my ($self) = @_;
   return @{$self->{'_rstseqs'} || []};
}



sub add_rst_tree{
   my ($self,$tree) = @_;
   if( $tree ) {
       unless( $tree->isa("Bio::Tree::TreeI") ) {
       $self->warn("Must provide a valid Bio::Tree::TreeI to add_rst_tree not $tree");
       return;
       }
       push @{$self->{'_rsttrees'}},$tree;
   }
}


sub reset_rst_trees{
   my ($self) = @_;
   $self->{'_rsttrees'} = [];
}


sub get_rst_trees{
   my ($self) = @_;
   return @{$self->{'_rsttrees'} || []};
}


sub set_rst_persite{
    my $self = shift;

    return $self->{'_rstpersite'} = shift if @_;
    return $self->{'_rstpersite'};
}


sub get_rst_persite{
   my ($self) = @_;
   return $self->{'_rstpersite'} || [];
}



1;

__END__