def __handle_single_allele(self, request): '''Child with one determined hap and full data ==> determine other child allele. Also, if parent of other allele has missing data, impute parent using child's data.''' problem, params = request.problem, request.params g, h, trio = problem.genotype.data, problem.haplotype.data, problem.kids_trios(params.selected_samples) if params.selected_mode else problem.trios() if not trio.size: return False child = trio[:, CHILD] gc = g[:, child, :] child_has_full_genotype = (gc[:, :, PATERNAL] != MISSING) & (gc[:, :, MATERNAL] != MISSING) for parent_type in ALLELES: other = 1 - parent_type # Other parent's genotype parent_other = trio[:, other] go = g[:, parent_other, :] # Corresponding child haplotypes hp, ho = h[:, child, parent_type], h[:, child, other] # Restrict view to relevant snps and samples: # child parent_type allele is determined; other allele is missing; child has full genotype j = np.where(child_has_full_genotype & (hp != MISSING) & (ho == MISSING)) gc_rel = gc[j[0], j[1], :] # Determine child haplotype corresponding to other parent's allele other_child_genotype = gc_rel[np.where(gc_rel != np.transpose(np.tile(hp[j[0], j[1], :], (2, 1))))] h[j[0], child[j[1]], other] = other_child_genotype # If parent of other allele has missing data, impute parent using child's data for allele, snps in dict(zip(ALLELES, gt.index_first_missing(go[j[0], j[1], :]))).iteritems(): other_value = other_child_genotype[snps] # if self.debug: # print 'Imputing parent', (j[0][snps], parent_other[j[1]][snps], allele) # problem.info.imputed_genotype.append((j[0][snps], parent_other[j[1]][snps], allele,other_value)) g[j[0][snps], parent_other[j[1]][snps], allele] = other_value return False
def __phase_duo_child(self, problem, params, parent_type): '''A helper method that phases a child based on a single parent of type parent_type.''' # Find genotyped children whose parent is genotyped duo = pt.selected_duos(problem, params, parent_type) if not duo.size: return False g, h = problem.data gc, gp = g[:, duo[:, 0], :], g[:, duo[:, 1], :] # Restrict view to snps that are homozygous in parent hom = np.where(gt.is_homozygous(gp)[:, :]) parent_allele, gc_hom = gp[hom[0], hom[1], 0], gc[hom[0], hom[1], :] #------------------------------------------------------------------------------------ # Case A: Parent = (a,a), child = (b,b) and a != b (incompatible) ==> error #------------------------------------------------------------------------------------ j = np.where( np.logical_and( gt.is_homozygous(gc_hom)[:], gc_hom[:, 0] != parent_allele))[0] # Flag errors in both children and parents for i in xrange(2): problem.genotype_error(hom[0][j], duo[hom[1][j], i], 'Homozygous parent allele not found in child') #------------------------------------------------------------------------------------ # Case B: Parent = (a,a), child = (a,x) or (x,a), x in {0,1,2} (compatible) ==> # set child parent hap to a and other hap to the other child genotype (x) #------------------------------------------------------------------------------------ # Note: h[array,array,:] is not a reference into h like h[scalar,scalar,:]. Thus, # when setting h, we must use h[original coordinates here] = ... . This occurs # several times in the code of this file. # Determine child haplotype corresponding to the hom parent snps = gt.index_of(gc_hom, parent_allele) parent_allele_at_snps = parent_allele[snps] snp_index, child_index = hom[0][snps], duo[hom[1][snps], 0] h[snp_index, child_index, parent_type] = parent_allele_at_snps # Determine child haplotype corresponding to the other parent gc_rel = g[snp_index, child_index, :] other = np.where( gc_rel != np.transpose(np.tile(parent_allele_at_snps, (2, 1)))) h[snp_index[other[0]], child_index[other[0]], 1 - parent_type] = gc_rel[other] #------------------------------------------------------------------------------------ # Case C: Parent = (a,a), child = (0,x) or (x,0) (potentially compatible) ==> # impute child to a and set child hap to a #------------------------------------------------------------------------------------ for allele, snps in dict(zip(ALLELES, gt.index_first_missing(gc_hom))).iteritems(): parent_value = parent_allele[snps] snp_original = hom[0][snps] gc[snp_original, hom[1][snps], allele] = parent_value # if self.debug: # print 'Imputing child', (snp_original, hom[1][snps], allele, parent_value) # problem.info.imputed_genotype.append((snp_original, hom[1][snps], allele, parent_value)) h[snp_original, duo[hom[1][snps], 0], parent_type] = parent_value return False
def __phase_duo_child(self, problem, params, parent_type): '''A helper method that phases a child based on a single parent of type parent_type.''' # Find genotyped children whose parent is genotyped duo = pt.selected_duos(problem, params, parent_type) if not duo.size: return False g, h = problem.data gc, gp = g[:, duo[:, 0], :], g[:, duo[:, 1], :] # Restrict view to snps that are homozygous in parent hom = np.where(gt.is_homozygous(gp)[:, :]) parent_allele, gc_hom = gp[hom[0], hom[1], 0], gc[hom[0], hom[1], :] #------------------------------------------------------------------------------------ # Case A: Parent = (a,a), child = (b,b) and a != b (incompatible) ==> error #------------------------------------------------------------------------------------ j = np.where(np.logical_and(gt.is_homozygous(gc_hom)[:], gc_hom[:, 0] != parent_allele))[0] # Flag errors in both children and parents for i in xrange(2): problem.genotype_error(hom[0][j], duo[hom[1][j], i], 'Homozygous parent allele not found in child') #------------------------------------------------------------------------------------ # Case B: Parent = (a,a), child = (a,x) or (x,a), x in {0,1,2} (compatible) ==> # set child parent hap to a and other hap to the other child genotype (x) #------------------------------------------------------------------------------------ # Note: h[array,array,:] is not a reference into h like h[scalar,scalar,:]. Thus, # when setting h, we must use h[original coordinates here] = ... . This occurs # several times in the code of this file. # Determine child haplotype corresponding to the hom parent snps = gt.index_of(gc_hom, parent_allele) parent_allele_at_snps = parent_allele[snps] snp_index, child_index = hom[0][snps], duo[hom[1][snps], 0] h[snp_index, child_index, parent_type] = parent_allele_at_snps # Determine child haplotype corresponding to the other parent gc_rel = g[snp_index, child_index, :] other = np.where(gc_rel != np.transpose(np.tile(parent_allele_at_snps, (2, 1)))) h[snp_index[other[0]], child_index[other[0]], 1 - parent_type] = gc_rel[other] #------------------------------------------------------------------------------------ # Case C: Parent = (a,a), child = (0,x) or (x,0) (potentially compatible) ==> # impute child to a and set child hap to a #------------------------------------------------------------------------------------ for allele, snps in dict(zip(ALLELES, gt.index_first_missing(gc_hom))).iteritems(): parent_value = parent_allele[snps] snp_original = hom[0][snps] gc[snp_original, hom[1][snps], allele] = parent_value # if self.debug: # print 'Imputing child', (snp_original, hom[1][snps], allele, parent_value) # problem.info.imputed_genotype.append((snp_original, hom[1][snps], allele, parent_value)) h[snp_original, duo[hom[1][snps], 0], parent_type] = parent_value return False
def __impute_duo_parent(problem, params, parent_type): '''Child with two determined haps (a,b) and parent has (a,MISSING) or (MISSING,a) ==> impute parent to (a,b). A helper method to process a single parent_type''' duo = pt.selected_duos(problem, params, parent_type) if not duo.size: return False g, h = problem.data gp, hc = g[:, duo[:, 1], :], h[:, duo[:, 0], :] # Restrict view to SNPs with full child haplotype child = np.where((hc[:, :, PATERNAL] != MISSING) & (hc[:, :, MATERNAL] != MISSING)) gp_rel, hc = gp[child[0], child[1], :], hc[child[0], child[1], :] # Impute parent's first missing allele to be the corresponding child hap for allele, snps in dict(zip(ALLELES, gt.index_first_missing(gp_rel))).iteritems(): hc_value = hc[snps, :, parent_type] # if self.debug: # print 'Imputing parent', (full[0][snps], duo[full[1][snps],1], allele) # problem.info.imputed_genotype.append((full[0][snps], duo[full[1][snps],1], allele, hc_value)) g[child[0][snps], duo[child[1][snps], 1], allele] = hc_value return False
def __handle_single_allele(self, request): '''Child with one determined hap and full data ==> determine other child allele. Also, if parent of other allele has missing data, impute parent using child's data.''' problem, params = request.problem, request.params g, h, trio = problem.genotype.data, problem.haplotype.data, problem.kids_trios( params.selected_samples) if params.selected_mode else problem.trios() if not trio.size: return False child = trio[:, CHILD] gc = g[:, child, :] child_has_full_genotype = (gc[:, :, PATERNAL] != MISSING) & (gc[:, :, MATERNAL] != MISSING) for parent_type in ALLELES: other = 1 - parent_type # Other parent's genotype parent_other = trio[:, other] go = g[:, parent_other, :] # Corresponding child haplotypes hp, ho = h[:, child, parent_type], h[:, child, other] # Restrict view to relevant snps and samples: # child parent_type allele is determined; other allele is missing; child has full genotype j = np.where(child_has_full_genotype & (hp != MISSING) & (ho == MISSING)) gc_rel = gc[j[0], j[1], :] # Determine child haplotype corresponding to other parent's allele other_child_genotype = gc_rel[np.where( gc_rel != np.transpose(np.tile(hp[j[0], j[1], :], (2, 1))))] h[j[0], child[j[1]], other] = other_child_genotype # If parent of other allele has missing data, impute parent using child's data for allele, snps in dict( zip(ALLELES, gt.index_first_missing(go[j[0], j[1], :]))).iteritems(): other_value = other_child_genotype[snps] # if self.debug: # print 'Imputing parent', (j[0][snps], parent_other[j[1]][snps], allele) # problem.info.imputed_genotype.append((j[0][snps], parent_other[j[1]][snps], allele,other_value)) g[j[0][snps], parent_other[j[1]][snps], allele] = other_value return False