Bio::PopGen::HtSNP.3pm

Langue: en

Version: 2010-05-19 (ubuntu - 24/10/10)

Section: 3 (Bibliothèques de fonctions)

NAME

Bio::PopGen::HtSNP.pm- Select htSNP from a haplotype set

SYNOPSIS

     use Bio::PopGen::HtSNP;
 
     my $obj = Bio::PopGen::HtSNP->new($hap,$snp,$pop);
 
 

DESCRIPTION

Select the minimal set of SNP that contains the full information about the haplotype without redundancies.

Take as input the followin values:

- the haplotype block (array of array).
- the snp id (array).
- family information and frequency (array of array).

The final haplotype is generated in a numerical format and the SNP's sets can be retrieve from the module.

considerations:

- If you force to include a family with indetermination, the SNP's with indetermination will be removed from the analysis, so consider before to place your data set what do you really want to do.

- If two families have the same information (identical haplotype), one of them will be removed and the removed files will be stored classify as removed.

- Only are accepted for calculation A, C, G, T and - (as deletion) and their combinations. Any other value as n or ? will be considered as degenerations due to lack of information.

RATIONALE

On a haplotype set is expected that some of the SNP and their variations contribute in the same way to the haplotype. Eliminating redundancies will produce a minimal set of SNP's that can be used as input for a taging selection process. On the process SNP's with the same variation are clustered on the same group.

The idea is that because the tagging haplotype process is exponential. All redundant information we could eliminate on the tagging process will help to find a quick result.

CONSTRUCTORS

   my $obj = Bio::PopGen::HtSNP->new
     (-haplotype_block => \@haplotype_patterns,
      -snp_ids         => \@snp_ids,
      -pattern_freq    => \@pattern_name_and_freq);
 
 

where $hap, $snp and $pop are in the format:

   my $hap = [
              'acgt',
              'agtc',
              'cgtc'
             ];                     # haplotype patterns' id
 
   my $snp = [qw/s1 s2 s3 s4/];     # snps' Id's
 
   my $pop = [
              [qw/ uno    0.20/],
              [qw/ dos    0.20/],
              [qw/ tres   0.15/],
             ];                     # haplotype_pattern_id    Frequency
 
 

OBJECT METHODS

     See Below for more detailed summaries.
 
 

DETAILS

How the process is working with one example

Let's begin with one general example of the code.

Input haplotype:

   acgtcca-t
   cggtagtgc
   cccccgtgc
   cgctcgtgc
 
 

The first thing to to is to split the haplotype into characters.

   a       c       g       t       c       c       a       -       t
   c       g       g       t       a       g       t       g       c
   c       c       c       c       c       g       t       g       c
   c       g       c       t       c       g       t       g       c
 
 

Now we have to convert the haplotype to Upercase. This will produce the same SNP if we have input a or A.

   A       C       G       T       C       C       A       -       T
   C       G       G       T       A       G       T       G       C
   C       C       C       C       C       G       T       G       C
   C       G       C       T       C       G       T       G       C
 
 

The program admit as values any combination of ACTG and - (deletions). The haplotype is converted to number, considering the first variation as zero and the alternate value as 1 (see expanded description below).

   0       0       0       0       0       0       0       0       0
   1       1       0       0       1       1       1       1       1
   1       0       1       1       0       1       1       1       1
   1       1       1       0       0       1       1       1       1
 
 

Once we have the haplotype converted to numbers we have to generate the snp type information for the haplotype.

SNP code = SUM ( value * multiplicity ^ position );

     where:
       SUM is the sum of the values for the SNP
       value is the SNP number code (0 [generally for the mayor allele],
                                     1 [for the minor allele].
       position is the position on the block.
 
 

For this example the code is:

   0       0       0       0       0       0       0       0       0
   1       1       0       0       1       1       1       1       1
   1       0       1       1       0       1       1       1       1
   1       1       1       0       0       1       1       1       1
  ------------------------------------------------------------------
   14      10      12      4       2       14      14      14      14
 
   14 = 0*2^0 + 1*2^1 + 1*2^2 + 1*2^3
   12 = 0*2^0 + 1*2^1 + 0*2^2 + 1*2^3
   ....
 
 

Once we have the families classify. We will take just the SNP's not redundant.

   14      10      12      4       2
 
 

This information will be passed to the tag module is you want to tag the htSNP.

Whatever it happens to one SNPs of a class will happen to a SNP of the same class. Therefore you don't need to scan redundancies

Working with fuzzy data.

This module is designed to work with fuzzy data. As the source of the haplotype is diverse. The program assume that some haplotypes can be generated using different values. If there is any indetermination (? or n) or any other degenerated value or invalid. The program will take away This SNP and will leave that for a further analysis.

On a complex situation:

   a       c       g       t       ?       c       a       c       t
   a       c       g       t       ?       c       a       -       t
   c       g       ?       t       a       g       ?       g       c
   c       a       c       t       c       g       t       g       c
   c       g       c       t       c       g       t       g       c
   c       g       g       t       a       g       ?       g       c
   a       c       ?       t       ?       c       a       c       t
 
 

On this haplotype everything is happening. We have a multialelic variance. We have indeterminations. We have deletions and we have even one SNP which is not a real SNP.

The buiding process will be the same on this situation.

Convert the haplotype to uppercase.

   A       C       G       T       ?       C       A       C       T
   A       C       G       T       ?       C       A       -       T
   C       G       ?       T       A       G       ?       G       C
   C       A       C       T       C       G       T       G       C
   C       G       C       T       C       G       T       G       C
   C       G       G       T       A       G       ?       G       C
   A       C       ?       T       ?       C       A       C       T
 
 

All columns that present indeterminations will be removed from the analysis on this Step.

hapotype after remove columns:

   A       C       T       C       C       T
   A       C       T       C       -       T
   C       G       T       G       G       C
   C       A       T       G       G       C
   C       G       T       G       G       C
   C       G       T       G       G       C
   A       C       T       C       C       T
 
 

All changes made on the haplotype matrix, will be also made on the SNP list.

   snp_id_1 snp_id_2 snp_id_4 snp_id_6 snp_id_8 snp_id_9
 
 

now the SNP that is not one SNP will be removed from the analysis. SNP with Id snp_id_4 (the one with all T's).

because of the removing. Some of the families will become the same and will be clustered. A posteriori analysis will diference these families. but because of the indetermination can not be distinguish.

   A       C       C       C       T
   A       C       C       -       T
   C       G       G       G       C
   C       A       G       G       C
   C       G       G       G       C
   C       G       G       G       C
   A       C       C       C       T
 
 

The result of the mergering will go like:

   A       C       C       C       T
   A       C       C       -       T
   C       G       G       G       C
   C       A       G       G       C
 
 

Once again the changes made on the families and we merge the frequency (to be implemented)

Before to convert the haplotype into numbers we consider how many variations we have on the set. On this case the variations are 3.

The control code will use on this situation base three as mutiplicity

   0       0       0       0       0
   0       0       0       1       0
   1       1       1       2       1
   1       2       1       2       1
  -----------------------------------
   36      63      36      75      36
 
 

And the minimal set for this combination is

   0       0       0
   0       0       1
   1       1       2
   1       2       2
 
 

NOTE: this second example is a remote example an on normal conditions. This conditions makes no sense, but as the haplotypes, can come from many sources we have to be ready for all kind of combinations.

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 the Bioperl mailing list. Your participation is much appreciated.
   bioperl-l@bioperl.org                  - General discussion
   http://bioperl.org/wiki/Mailing_lists  - About the mailing lists
 
 

Support

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

bioperl-l@bioperl.org

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:
   http://bugzilla.open-bio.org/
 
 

AUTHOR - Pedro M. Gomez-Fabre

Email pgf18872-at-gsk-dot-com

APPENDIX

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

new

  Title   : new
  Function: constructor of the class.
  Usage   : $obj-> Bio::PopGen::HtSNP->new(-haplotype_block
                                           -snp_ids
                                           -pattern_freq)
  Returns : self hash
  Args    : input haplotype (array of array)
            snp_ids         (array)
            pop_freq        (array of array)
  Status  : public
 
 

haplotype_block

  Title   : haplotype_block 
  Usage   : my $haplotype_block = $HtSNP->haplotype_block();
  Function: Get the haplotype block for a haplotype tagging selection
  Returns : reference of array 
  Args    : reference of array with haplotype pattern
 
 

snp_ids

  Title   : snp_ids 
  Usage   : my $snp_ids = $HtSNP->$snp_ids();
  Function: Get the ids for a haplotype tagging selection
  Returns : reference of array
  Args    : reference of array with SNP ids
 
 

pattern_freq

  Title   : pattern_freq
  Usage   : my $pattern_freq = $HtSNP->pattern_freq();
  Function: Get the pattern id and frequency  for a haplotype
            tagging selection
  Returns : reference of array
  Args    : reference of array with SNP ids
 
 

_check_input

  Title   : _check_input
  Usage   : _check_input($self)
  Function: check for errors on the input
  Returns : self hash
  Args    : self
  Status  : internal
 
 

_haplotype_length_error

  Title   : _haplotype_length_error
  Usage   : _haplotype_length_error($self)
  Function: check if the haplotype length is the same that the one on the
            SNP id list. If not break and exit
  Returns : self hash
  Args    : self
  Status  : internal
 
 

_population_error

  Title   : _population_error
  Usage   : _population_error($self)
  Function: use input_block and pop_freq test if the number of elements
            match. If doesn't break and quit.
  Returns : self hash
  Args    : self
  Status  : internal
 
 

_do_it

  Title   : _do_it
  Usage   : _do_it($self)
  Function: Process the input generating the results.
  Returns : self hash
  Args    : self
  Status  : internal
 
 

input_block

  Title   : input_block
  Usage   : $obj->input_block()
  Function: returns input block
  Returns : reference to array of array
  Args    : none
  Status  : public
 
 

hap_length

  Title   : hap_length
  Usage   : $obj->hap_length()
  Function: get numbers of SNP on the haplotype
  Returns : scalar
  Args    : none
  Status  : public
 
 

pop_freq

  Title   : pop_freq
  Usage   : $obj->pop_freq()
  Function: returns population frequency
  Returns : reference to array
  Args    : none
  Status  : public
 
 

deg_snp

  Title   : deg_snp
  Usage   : $obj->deg_snp()
  Function: returns snp_removes due to indetermination on their values
  Returns : reference to array
  Args    : none
  Status  : public
 
 

snp_type

  Title   : snp_type
  Usage   : $obj->snp_type()
  Function: returns hash with SNP type
  Returns : reference to hash
  Args    : none
  Status  : public
 
 

silent_snp

  Title   : silent_snp
  Usage   : $obj->silent_snp()
  Function: some SNP's are silent (not contibuting to the haplotype)
            and are not considering for this analysis
  Returns : reference to a array
  Args    : none
  Status  : public
 
 

useful_snp

  Title   : useful_snp
  Usage   : $obj->useful_snp()
  Function: returns list of SNP's that are can be used as htSNP. Some
            of them can produce the same information. But this is
            not considered here.
  Returns : reference to a array
  Args    : none
  Status  : public
 
 

ht_type

  Title   : ht_type
  Usage   : $obj->ht_type()
  Function: every useful SNP has a numeric code dependending of its
            value and position. For a better description see
            description of the module.
  Returns : reference to a array
  Args    : none
  Status  : public
 
 

ht_set

  Title   : ht_set
  Usage   : $obj->ht_set()
  Function: returns the minimal haplotype in numerical format. This
            haplotype contains the maximal information about the
            haplotype variations but with no redundancies. It's the
            minimal set that describes the haplotype.
  Returns : reference to an array of arrays
  Args    : none
  Status  : public
 
 

snp_type_code

  Title   : snp_type_code
  Usage   : $obj->snp_type_code()
  Function: returns the numeric code of the SNPs that need to be
            tagged that correspond to the SNP's considered in ht_set.
  Returns : reference to an array
  Args    : none
  Status  : public
 
 

snp_and_code

  Title   : snp_and_code
  Usage   : $obj->snp_and_code()
  Function: Returns the full list of SNP's and the code associate to
            them. If the SNP belongs to the group useful_snp it keep
            this code. If the SNP is silent the code is 0. And if the
            SNP is degenerated the code is -1.
  Returns : reference to an array of array
  Args    : none
  Status  : public
 
 

deg_pattern

  Title   : deg_pattern
  Usage   : $obj->deg_pattern()
  Function: Returns the a list with the degenerated haplotype.
            Sometimes due to degeneration some haplotypes looks
            the same and if we don't remove them it won't find
            any tag.
  Returns : reference to a hash of array
  Args    : none
  Status  : public
 
 

split_hap

  Title   : split_hap
  Usage   : $obj->split_hap()
  Function: simple representation of the haplotype base by base
            Same information that input haplotype but base based.
  Returns : reference to an array of array
  Args    : none
  Status  : public
 
 

_split_haplo

  Title   : _split_haplo
  Usage   : _split_haplo($self)
  Function: Take a haplotype and split it into bases
  Returns : self
  Args    : none
  Status  : internal
 
 

_to_upper_case

  Title   : _to_upper_case
  Usage   : _to_upper_case()
  Function: make SNP or in-dels Upper case
  Returns : self
  Args    : an AoA ref
  Status  : private
 
 

_remove_deg

  Title   : _remove_deg
  Usage   : _remove_deg()
  Function: when have a indetermination or strange value this SNP
            is removed
  Returns : haplotype family set and degeneration list
  Args    : ref to an AoA and a ref to an array
  Status  : internal
 
 

_rem_silent_snp

  Title   : _rem_silent_snp
  Usage   : _rem_silent_snp()
  Function: there is the remote possibilty that one SNP won't be a
            real SNP on this situation we have to remove this SNP,
            otherwise the program won't find any tag
  Returns : nonthing
  Args    : ref to an AoA and a ref to an array
  Status  : internal
 
 

_find_silent_snps

  Title   : _find_silent_snps
  Usage   :
  Function: list of snps that are not SNPs. All values for that
            SNPs on the set is the same one. Look stupid but can
            happend and if this happend you will not find any tag
  Returns : nothing
  Args    :
  Status  :
 
 

_find_indet

  Title   : _find_indet
  Usage   :
  Function: find column (SNP) with invalid or degenerated values
            and store this values into the second parameter suplied.
  Returns : nothing
  Args    : ref to AoA and ref to an array
  Status  : internal
 
 

_remove_col

  Title   : _remove_col
  Usage   :
  Function: remove columns contained on the second array from
            the first arr
  Returns : nothing
  Args    : array of array reference and array reference
  Status  : internal
 
 

_remove_snp_id

  Title   : _remove_snp_id
  Usage   :
  Function: remove columns contained on the second array from
            the first arr
  Returns : nothing
  Args    : array of array reference and array reference
  Status  : internal
 
 

_find_deg_pattern

  Title   : _find_deg_pattern
  Usage   :
  Function: create a list with the degenerated patterns
  Returns : @array
  Args    : a ref to AoA
  Status  : public
 
 

_keep_these_patterns

  Title   : _keep_these_patterns
  Usage   :
  Function: this is a basic approach, take a LoL and a list,
            keep just the columns included on the list
  Returns : nothing
  Args    : an AoA and an array
  Status  : public
 
 

compare_arrays

  Title   : compare_arrays
  Usage   :
  Function: take two arrays and compare their values
  Returns : 1 if the two values are the same
            0 if the values are different
  Args    : an AoA and an array
  Status  : public
 
 

_convert_to_numbers

  Title   : _convert_to_numbers
  Usage   : _convert_to_numbers()
  Function: tranform the haplotype into numbers. before to do that
            we have to consider the variation on the set.
  Returns : nonthing
  Args    : ref to an AoA and a ref to an array
  Status  : internal
 
 

_snp_type_code

  Title   : _snp_type_code
  Usage   :
  Function:
            we have to create the snp type code for each version.
            The way the snp type is created is the following:
 
            we take the number value for every SNP and do the
            following calculation
 
            let be a SNP set as follow:
 
            0    0
            1    1
            1    2
 
            and multiplicity 3
            on this case the situation is:
 
            sum (value * multiplicity ^ position) for each SNP
 
            0 * 3 ^ 0 + 1 * 3 ^ 1 + 1 * 3 ^ 2 = 12
            0 * 3 ^ 0 + 1 * 3 ^ 1 + 2 * 3 ^ 2 = 21
  Returns : nothing
  Args    : $self
  Status  : private
 
 

_alleles_number

  Title   : _alleles_number
  Usage   :
  Function: calculate the max number of alleles for a haplotype and
            if the number. For each SNP the number is stored and the
            max number of alleles for a SNP on the set is returned
  Returns : max number of alleles (a scalar storing a number)
  Args    : ref to AoA
  Status  : public
 
 

_htSNP

  Title   : _htSNP
  Usage   : _htSNP()
  Function: calculate the minimal set that contains all information of the
            haplotype.
  Returns : nonthing
  Args    : ref to an AoA and a ref to an array
  Status  : internal
 
 

_snp_and_code_summary

  Title   : _snp_and_code_summary
  Usage   : _snp_and_code_summary()
  Function: compile on a list all SNP and the code for each. This
            information can be also obtained combining snp_type and
            snp_type_code but on these results the information about
            the rest of SNP's are not compiled as table.
 
            0 will be silent SNPs
            -1 are degenerated SNPs
            and the rest of positive values are the code for useful SNP
 
  Returns : nonthing
  Args    : ref to an AoA and a ref to an array
  Status  : internal