net.maizegenetics.analysis.popgen

Class LinkageDisequilibrium

net.maizegenetics.analysis.popgen.LinkageDisequilibrium

All Implemented Interfaces:

TableReport

public class LinkageDisequilibrium
implements TableReport

This class calculates D' and r^2 estimates of linkage disequilibrium. It also calculates the significance of the LD by either Fisher Exact or the multinomial permutation test. This class can work with either normal alignments of annotated alignments. The alignments should be stripped of invariable numSites.

enum LinkageDisequilibrium.testDesign sets matrix design for LD calculation. Either all by all, sliding window, site by all, or site list.

There are multiple approaches for dealing with heterozygous sites. enum LinkageDisequilibrium.HetTreatment sets the way these are treated. Haplotype assumes fully phased heterozygous sites (any hets are double counted). This is the best approach for speed when things are fully phased. Homozygous converted all hets to missing. Genotype does a 3x3 genotype analysis (to be implemented)

2 state estimates of D' and r^2 can be found reviewed and discussed in Weir 1996

Multi-state loci (>=3) require an averaging approach. In TASSEL 3 in 2010, Buckler removed these approach as the relative magnitudes and meaningfulness of these approaches has never been clear. Additionally with the moving away from SSR to SNPs these methods are less relevant. Researchers should convert to biallelic - either by ignoring rarer classes or collapsing rarer states.

TODO: Add 3x3 (genotype) mode.

See Also:

enum LinkageDisequilibrium.testDesign, enum LinkageDisequilibrium.HetTreatment

Constructor Detail

LinkageDisequilibrium

public LinkageDisequilibrium(GenotypeTable alignment,
                             int windowSize,
                             net.maizegenetics.analysis.popgen.LinkageDisequilibrium.testDesign LDType,
                             int testSite,
                             ProgressListener listener,
                             boolean isAccumulativeReport,
                             int numAccumulateIntervals,
                             kotlin.Array[] sitesList,
                             net.maizegenetics.analysis.popgen.LinkageDisequilibrium.HetTreatment hetTreatment)

Constructor for doing LD analysis

Parameters:

alignment - Input alignment with segregating sites

windowSize - Size of sliding window

LDType -

testSite -

listener -

isAccumulativeReport -

numAccumulateIntervals -

sitesList -

hetTreatment -

Method Detail

run

public void run()

starts the thread to calculate LD

calculateBitLDForHaplotype

public static LDResult calculateBitLDForHaplotype(boolean ignoreHets,
                                                  int minTaxaForEstimate,
                                                  GenotypeTable alignment,
                                                  int site1,
                                                  int site2)

calculateBitLDForHaplotype

public static LDResult calculateBitLDForHaplotype(int minTaxaForEstimate,
                                                  int minorCnt,
                                                  GenotypeTable alignment,
                                                  int site1,
                                                  int site2)

calculateDPrime

public static double calculateDPrime(int countAB,
                                     int countAb,
                                     int countaB,
                                     int countab,
                                     int minTaxaForEstimate)

calculateRSqr

public static double calculateRSqr(int countAB,
                                   int countAb,
                                   int countaB,
                                   int countab,
                                   int minTaxaForEstimate)

getLDForSitePair

public static LDResult getLDForSitePair(BitSet rMj,
                                        BitSet rMn,
                                        BitSet cMj,
                                        BitSet cMn,
                                        int minMinorCnt,
                                        int minCnt,
                                        float minR2,
                                        FisherExact myFisherExact,
                                        int site1Index,
                                        int site2Index)

Method for estimating LD between a pair of bit sets. Since there can be tremendous missing data, minimum minor and minimum site counts ensure that meaningful results are estimated. Site indices are merely there for annotating the LDResult.

Parameters:

rMj - site 1 major alleles

rMn - site 1 minor alleles

cMj - site 2 major alleles

cMn - site 2 minor alleles

minMinorCnt - minimum minor allele count after intersection

minCnt - minimum count after intersection

minR2 - results below this r2 are ignored for p-value calculation (save times)

myFisherExact -

site1Index - annotation of LDresult with sites indices

site2Index - annotation of LDresult with sites indices

Returns:

org.jetbrains.dokka.NodeRenderContent@7f4e76ed:

getPVal

public double getPVal(int r,
                      int c)

Returns P-value estimate for a given pair of numSites. If there were only 2 alleles at each locus, then the Fisher Exact P-value (one-tail) is returned. If more states then the permuted Monte Carlo test is used.

Parameters:

r - is site 1

c - is site 2

Returns:

org.jetbrains.dokka.NodeRenderContent@69e3e36c: P-value

getSampleSize

public int getSampleSize(int r,
                         int c)

Get number of gametes included in LD calculations (after missing data was excluded)

Parameters:

r - is site 1

c - is site 2

Returns:

org.jetbrains.dokka.NodeRenderContent@2cbf1301: number of gametes

getDPrime

public float getDPrime(int r,
                       int c)

Returns D' estimate for a given pair of numSites

Parameters:

r - is site 1

c - is site 2

Returns:

org.jetbrains.dokka.NodeRenderContent@533ba984: D'

getRSqr

public float getRSqr(int r,
                     int c)

Returns r^2 estimate for a given pair of numSites

Parameters:

r - is site 1

c - is site 2

Returns:

org.jetbrains.dokka.NodeRenderContent@5fce5410: r^2

getX

public int getX(int row)

getY

public int getY(int row)

getSiteCount

public int getSiteCount()

Returns the counts of the numSites in the alignment

getAlignment

public GenotypeTable getAlignment()

Returns an annotated aligment if one was used for this LD this could be used to access information of locus position

toString

public java.lang.String toString()

Returns representation of the LD results as a string

getTableColumnNames

public java.lang.Object[] getTableColumnNames()

getRow

public java.lang.Object[] getRow(long row)

getTableTitle

public java.lang.String getTableTitle()

getColumnCount

public int getColumnCount()

getRowCount

public long getRowCount()

getElementCount

public long getElementCount()

getValueAt

public java.lang.Object getValueAt(long row,
                                   int col)

fireProgress

protected void fireProgress(int percent)