Exemple #1
0
    def compute_probabilities(self, c, err, q1, q2, q, g, *_):
        b_o = self.get_b_o(q1, q2, q)
        threshold_o = self.get_hist_threshold(b_o, self.threshold)

        # read to kmer coverage
        c = self.correct_c(c)

        # lambda for kmers with s errors
        l_s = self._get_lambda_s(c, err)
        pl_s = [(s * 0.5) for s in l_s]

        # expected probability of kmers with s errors and coverage >= 1
        # noinspection PyTypeChecker
        n_os = [None] + [[
            self.comb[s] * (1.0 - exp(o * -l_s[s]))
            for s in range(self.max_error)
        ] for o in range(1, threshold_o)]
        sum_n_os = [None] + [
            fix_zero(sum(n_os[o][t] for t in range(self.max_error)))
            for o in range(1, threshold_o)
        ]

        pn_os = [None] + [[
            self.comb[s] * (1.0 - exp(o * -pl_s[s]))
            for s in range(self.max_error)
        ] for o in range(1, threshold_o)]
        sum_pn_os = [None] + [
            fix_zero(sum(pn_os[o][t] for t in range(self.max_error)))
            for o in range(1, threshold_o)
        ]

        # portion of kmers wit1h s errors
        # noinspection PyTypeChecker
        a_os = [None] + [[
            n_os[o][s] / (sum_n_os[o] if sum_n_os[o] != 0 else 1)
            for s in range(self.max_error)
        ] for o in range(1, threshold_o)]

        pa_os = [None] + [[
            pn_os[o][s] / (sum_pn_os[o] if sum_pn_os[o] != 0 else 1)
            for s in range(self.max_error)
        ] for o in range(1, threshold_o)]

        # probability that unique kmer has coverage j (j > 0)
        p_j = {
            j: (1 - g) * sum(
                b_o(o) * sum(a_os[o][s] * tr_poisson(o * l_s[s], j)
                             for s in range(self.max_error))
                for o in range(1, threshold_o)) + g * sum(
                    b_o(o) * sum(pa_os[o][s] * tr_poisson(o * pl_s[s], j)
                                 for s in range(self.max_error))
                    for o in range(1, threshold_o))
            for j in self.hist
        }
        return p_j
Exemple #2
0
    def compute_probabilities(self, c, err, q1, q2, q, *_):
        b_o = self.get_b_o(q1, q2, q)
        threshold_o = self.get_hist_threshold(b_o, self.threshold)
        # read to kmer coverage
        c = self.correct_c(c)
        # lambda for kmers with s errors
        l_s = self._get_lambda_s(c, err)
        # expected probability of kmers with s errors and coverage >= 1
        # noinspection PyTypeChecker
        n_os = [None] + [
            [self.comb[s] * (1.0 - exp(o * -l_s[s])) for s in range(self.max_error)]
            for o in range(1, threshold_o)
        ]
        sum_n_os = [None] + [
            fix_zero(sum(n_os[o][t] for t in range(self.max_error))) for o in range(1, threshold_o)
        ]

        # portion of kmers wit1h s errors
        # noinspection PyTypeChecker
        a_os = [None] + [
            [n_os[o][s] / (sum_n_os[o] if sum_n_os[o] != 0 else 1) for s in range(self.max_error)]
            for o in range(1, threshold_o)
        ]
        # probability that unique kmer has coverage j (j > 0)
        p_j = {
            j: sum(
                b_o(o) * sum(
                    a_os[o][s] * tr_poisson(o * l_s[s], j) for s in range(self.max_error)
                ) for o in range(1, threshold_o)
            ) for j in self.hist
        }
        return p_j
Exemple #3
0
    def compute_polymorphism_rate(self, c, err, g, genome_size):
        ck = self.correct_c(c) / 2.0
        # lambda for kmers with s errors --- lambda pre k-mery s 's' chybami
        l_s = self._get_lambda_s(ck, err)
        # expected probability of kmers with s errors and coverage >= 1 --- ocakavana pravdepodobnost kmerov s 's' chybami a pokrytim aspon 1
        n_s = [
            self.comb[s] * (1.0 - exp(-l_s[s])) for s in range(self.max_error)
        ]
        sum_n_s = fix_zero(sum(
            n_s[t]
            for t in range(self.max_error)))  # suma tychto pravdepodobnosti
        # portion of kmers with s errors --- pomer kmerov s 's' chybami
        a_s = [n_s[s] / sum_n_s for s in range(self.max_error)]
        # probability that unique kmer has coverage j (j > 0) --- pravdepodobnost, ze dany kmer ma pokrytie j (j > 0)
        p_j = {
            j:
            sum(a_s[s] * tr_poisson(l_s[s], j) for s in range(self.max_error))
            for j in range(1,
                           max(self.orig_hist.keys()) // 2)
        }

        x_pd = g * self.total_distinct_kmers
        sum_pp = sum([j * p_j[j] for j in p_j])
        p_kmers = (x_pd * sum_pp) / (2 * genome_size * self.correct_c(c) / 2.0)
        p = 1 - (1 - p_kmers)**(1.0 / self.k)

        return p
Exemple #4
0
    def compute_probabilities(self, c, err, g, *_):
        # read to kmer coverage
        ck = self.correct_c(c)

        # lambda for non-polymorphic kmers with s errors
        l_s = self._get_lambda_s(ck, err)

        # lambda for polymorfic k-mers
        pl_s = [(s * 0.5) for s in l_s]

        # expected probability of non-polymorphic kmers with s errors and coverage >= 1
        n_s = [
            self.comb[s] * (1.0 - exp(-l_s[s])) for s in range(self.max_error)
        ]
        sum_n_s = fix_zero(sum(n_s[t] for t in range(self.max_error)))

        # expected probability of polymorphic kmers with s errors and coverage >= 1
        pn_s = [
            self.comb[s] * (1.0 - exp(-pl_s[s])) for s in range(self.max_error)
        ]
        sum_pn_s = fix_zero(sum(
            pn_s[t]
            for t in range(self.max_error)))  # suma tychto pravdepodobnosti

        # portion of non-polymorphic kmers with s errors
        a_s = [n_s[s] / sum_n_s for s in range(self.max_error)]

        # portion of non-polymorphic kmers with s errors
        pa_s = [pn_s[s] / sum_pn_s for s in range(self.max_error)]

        # probability that unique kmer has coverage j (j > 0)

        p_j = {
            j: (1 - g) * sum(a_s[s] * tr_poisson(l_s[s], j)
                             for s in range(self.max_error)) +
            g * sum(pa_s[s] * tr_poisson(pl_s[s], j)
                    for s in range(self.max_error))
            for j in self.hist
        }

        return p_j
Exemple #5
0
 def compute_probabilities(self, c, err, *_):
     # read to kmer coverage
     ck = self.correct_c(c)
     # lambda for kmers with s errors
     l_s = self._get_lambda_s(ck, err)
     # expected probability of kmers with s errors and coverage >= 1
     n_s = [self.comb[s] * (1.0 - exp(-l_s[s])) for s in range(self.max_error)]
     sum_n_s = fix_zero(sum(n_s[t] for t in range(self.max_error)))
     # portion of kmers with s errors
     a_s = [n_s[s] / sum_n_s for s in range(self.max_error)]
     # probability that unique kmer has coverage j (j > 0)
     p_j = {
         j: sum(
             a_s[s] * tr_poisson(l_s[s], j) for s in range(self.max_error)
         )
         for j in self.hist
     }
     return p_j
Exemple #6
0
 def compute_probabilities(self, c, err, *_):
     # read to kmer coverage
     ck = self.correct_c(c)
     # lambda for kmers with s errors
     l_s = self._get_lambda_s(ck, err)
     # expected probability of kmers with s errors and coverage >= 1
     n_s = [
         self.comb[s] * (1.0 - exp(-l_s[s])) for s in range(self.max_error)
     ]
     sum_n_s = fix_zero(sum(n_s[t] for t in range(self.max_error)))
     # portion of kmers with s errors
     a_s = [n_s[s] / sum_n_s for s in range(self.max_error)]
     # probability that unique kmer has coverage j (j > 0)
     p_j = {
         j:
         sum(a_s[s] * tr_poisson(l_s[s], j) for s in range(self.max_error))
         for j in self.hist
     }
     return p_j