def extract_hitseq(self,seq_buil,CloFre,Cut): Align=MegaAlignment() CloLs,Clo2Seq=Align.name2seq(seq_buil) Hit={} for Clo in CloFre: if CloFre[Clo]>Cut: Hit['#'+Clo]=Clo2Seq['#'+Clo] return Hit
def save_without_cloneID(self, Cell2BestSeq): Align = MegaAlignment() tree_builder = MegaML() tree_analyzer = TreeAnalizer() BestSeq_builder_3 = Align.UpMeg(Cell2BestSeq, self.CellLs) Align.save_mega_alignment_to_file(self.out_file_name, BestSeq_builder_3)
def __init__(self, seqs_with_ancestor, v_obs, CNV_info, freq_cutoff): self.CutOff = freq_cutoff Align = MegaAlignment() self.ini_clone_order, self.ini_clone_seq = Align.name2seq( seqs_with_ancestor) self._CNV_file = CNV_info self.v_obs = v_obs
def do_mega_mp(self, alignment_builder, mega_id): self._newick_trees = [] print('constructing MP tree') result = False self._update_file_names(mega_id) Align = MegaAlignment() Align.save_mega_alignment_to_file(self._alignment_file, alignment_builder) cl = self._command_line_string() os.system(cl) if os.path.isfile(self._newick_file) == True: result = True nf = open(self._newick_file, 'r') ns = nf.readlines() for line in ns: self._newick_trees.append(line) nf.close() files = self._get_ancestral_states_files() self._retrieve_ancestral_states() seq_maker = MakeAncSeqMPMin() self.best_align_result = seq_maker.get_best_alignment( files, self._mega_id, True, self.newick_trees) self._cleanup_temp_files() return result
def do_mega_pp(self, alignment_builder, tree_builder, mega_id): print 'computing PP' result = False self._update_file_names(mega_id) Align = MegaAlignment() Align.save_mega_alignment_to_file(self._alignment_file, alignment_builder) ### self.save_str_to_file(tree_builder, self._input_tree_file) cl = self._command_line_string() os.system(cl) PPfileLs = glob.glob(self._pp_file[:-4] + 'seq-*.csv') if PPfileLs != []: result = True for PPfile in PPfileLs: shutil.copyfile(PPfile, PPfile.split('\\')[-1]) # print result return result
def EstimateSNVfre(self, Tu2CloFre, clone_seq0, ReadCount): Align = MegaAlignment() cloorder, clone_seq = Align.name2seq(clone_seq0) tumor2estSNV = {} tumor2diff = {} for tumor in Tu2CloFre: clone2frequency = Tu2CloFre[tumor] tumor = tumor.split('-')[-1] estSNVfreLs = [] DiffLs = [] snv_num = len(ReadCount[tumor + ':ref']) c = 0 while c < snv_num: estSNVfre = 0 for Clo in clone2frequency: S = clone_seq['#' + Clo] if str(clone2frequency[Clo]).find('e') != -1: F = 0 else: F = clone2frequency[Clo] / 2 if S[c] == 'T': estSNVfre += F estSNVfreLs.append(estSNVfre) Obs = 1.0 * float(ReadCount[tumor + ':alt'][c]) / ( float(ReadCount[tumor + ':alt'][c]) + float(ReadCount[tumor + ':ref'][c])) Dif = estSNVfre - Obs DiffLs.append(Dif) c += 1 tumor2estSNV[tumor] = estSNVfreLs tumor2diff[tumor] = DiffLs return tumor2estSNV, tumor2diff
def findcombohit(self,seq_builder): Align=MegaAlignment() SeqLs,SeqDic=Align.name2seq(seq_builder) Find='n' for i in SeqLs: if i.find('Clu')!=-1: Find='y' return Find
def fill_cloneseq(self): Align=MegaAlignment() Cell2BestSeq={} for Clone in self.Clone2CellLs: CellLs=self.Clone2CellLs[Clone] DiffNucPosiLs=Align.GetDiffPosi(CellLs, self.Cell2Seq) Posi2Nuc={} for Posi in DiffNucPosiLs: Nuc2PPls={'A':[],'T':[]} for Cell in CellLs: Nuc2PPls['A'].append(self.Cell2PPls[Cell][Posi]['A']) Nuc2PPls['T'].append(self.Cell2PPls[Cell][Posi]['T']) TAve=sum(Nuc2PPls['T'])/len(Nuc2PPls['T']) AAve=sum(Nuc2PPls['A'])/len(Nuc2PPls['A']) if TAve>AAve: Posi2Nuc[Posi]='T' else: Posi2Nuc[Posi]='A' for Cell in CellLs: CellSeq=self.Cell2Seq['#'+Cell] c=0 NewSeq='' while c<self.SNVnum: if CellSeq[c]=='?': NewSeq+='?' elif Posi2Nuc.has_key(c)!=True: NewSeq+=CellSeq[c] else: NewSeq+=Posi2Nuc[c] c+=1 Cell2BestSeq['#'+Cell]=NewSeq self.save_with_cloneID(Cell2BestSeq) self.save_without_cloneID(Cell2BestSeq)
def do_mega_mp(self, alignment_builder, mega_id): self._newick_trees = [] print 'constructing MP tree' result = False self._update_file_names(mega_id) # print self._alignment_file Align = MegaAlignment() Align.save_mega_alignment_to_file(self._alignment_file, alignment_builder) cl = self._command_line_string() os.system(cl) if os.path.isfile(self._newick_file) == True: result = True nf = open(self._newick_file, 'r') ns = nf.readlines() print 'MP tree(s):' for line in ns: print line self._newick_trees.append(line) nf.close() self._retrieve_ancestral_states() # self._cleanup_temp_files() return result
def remove_ancestral_decomposed(self, remove_tumor_and_rename_decomposed_seq, Error_rate, tumor_seqs): # print 'Tu',tumor_seqs Align = MegaAlignment() SeqOrderIni, Meg2Seq = Align.name2seq( remove_tumor_and_rename_decomposed_seq) TuLs, Tu2Seq = Align.name2seq(tumor_seqs) good_seq = ['#MEGA', '!Title SNVs;', '!Format datatype=dna;', ' '] RmCluClo = [] for name1 in SeqOrderIni: if name1.find('Clu') != -1: seq1 = Meg2Seq[name1] for name2 in SeqOrderIni: if name2 != '#hg19' and name1 != name2: seq2 = Meg2Seq[name2] Additional_mut_num1 = Align.CountAdditionalMut( seq1, seq2) Der = 1.0 * Additional_mut_num1 / len(seq1) if name2.find('Clu') != -1: if Additional_mut_num1 == 0: RmCluClo.append(name1) else: if Der < Error_rate: RmCluClo.append(name1) AddedTuLs = [] for Name in SeqOrderIni: if RmCluClo.count(Name) == 0: good_seq += [Name, Meg2Seq[Name]] AddedTuLs.append(Name.split('Clu')[0]) for Tu in TuLs: if AddedTuLs.count(Tu) == 0: good_seq += [Tu, Tu2Seq[Tu]] good_seq += ['#hg19', 'A' * len(seq1)] return good_seq
def do_mega_ml(self, alignment_builder, mega_id): print('constructing ML tree') result = False self._update_file_names(mega_id) print(self._alignment_file) Align = MegaAlignment() Align.save_mega_alignment_to_file(self._alignment_file, alignment_builder) cl = self._command_line_string() os.system(cl) if os.path.isfile(self._newick_file) == True: result = True nf = open(self._newick_file, 'r') # ns = nf.readlines() print('ML tree:') # for line in ns: # print line self._newick_trees = nf.readlines()[0] print(self._newick_trees) nf.close() # self._retrieve_ancestral_states() # self._cleanup_temp_files() return result
def __init__(self, tumor_seq, tsp_list, mao_file): Align = MegaAlignment() self.tumor_list, self.tumor2seq = Align.name2seq(tumor_seq) self.Len = len(self.tumor2seq[self.tumor_list[0]]) self.mao_file = mao_file self.tsp_list = tsp_list TSPinfo = tsp_information(tsp_list) self.Tu2SNV = TSPinfo.tumor2alt_frequency()
def ReNameCloFreMeg(self, seqs, CloFre, Name): Align = MegaAlignment() CloFreAnalize = CloneFrequencyAnalizer() NameOrder, Clo2Seq = Align.name2seq(seqs) if CloFre == {}: CloFre['T-A'] = {} for Clo in Clo2Seq: CloFre['T-A'][Clo[1:]] = 1 # print Clo2Seq,seqs Len = len(Clo2Seq[NameOrder[0]]) out = [ '#MEGA', '!Title SNVs;', '!Format datatype=dna;', ' ', '#hg19', 'A' * Len ] TuLs = [] for Tu in CloFre: TuLs.append(Tu[3:]) TuLs.sort() Old2NewCloLs = {} Old2NewCloNum = {} CloOrder = [] Num = 1 for Tu in CloFre: Clo2Fre = CloFre[Tu] HitClo = [] for Clo in Clo2Fre: if Clo2Fre[Clo] > 0: HitClo.append(Clo) Tu = Tu[2:] C = 1 CloLs, Fre2Clo = CloFreAnalize.Sort(HitClo, Clo2Fre) #from large frequency for Clo in CloLs: Code = Clo in Old2NewCloLs if Code != True: Old2NewCloLs[Clo] = '' Old2NewCloNum[Clo] = 'Clone' + str(Num) CloOrder.append(Clo) Num += 1 Old2NewCloLs[Clo] += Tu + str(C) C += 1 if Name == 'list': Old2NewClo = Old2NewCloLs else: Old2NewClo = Old2NewCloNum NewCloOrder = [] NewT2C2F = {} for Clo in CloOrder: NewCloOrder.append(Old2NewClo[Clo]) out += ['#' + Old2NewClo[Clo], Clo2Seq['#' + Clo]] #+'\n' for Tu in CloFre: C2F = CloFre[Tu] NewC2F = {} for C in C2F: if C2F[C] > 0: NewC2F[Old2NewClo[C]] = C2F[C] NewT2C2F[Tu] = NewC2F return out, NewT2C2F, NewCloOrder
def save_with_cloneID(self, CellSeqDic): Align = MegaAlignment() outSeq_builder = ['#MEGA', '!Title SNVs;', '!Format datatype=dna;', ' '] for Clone in self.Clone2CellLs: CellLs = self.Clone2CellLs[Clone] for Cell in CellLs: outSeq_builder += ['#' + Cell + '_{' + Clone + '}', CellSeqDic['#' + Cell]] #######change Align.save_mega_alignment_to_file(self.out_file_name[:-4] + '_withCloneID.meg', outSeq_builder)
def find_decomposed_clone(self, no_back_para_mut_decomposed_seq, REP, Tree): Align = MegaAlignment() CloLs, Clo2Seq = Align.name2seq(no_back_para_mut_decomposed_seq) DecTipLs = [] DecLs = [] DecAncLs = [] RmDecom = [] for Clo in CloLs: # ClosestAnc = Align.find_closest_anc(Clo,Clo2Seq) # if ClosestAnc!='' : # DecAncLs.appned(Clo) if Clo.find('Clu') != -1: ID = 'REP' + str(REP) In = -1 * len(ID) if Clo[In:] == ID: DecLs.append(Clo) Posi = Tree.find(Clo[1:] + ':') + len(Clo) # print Tree[Posi] Go = 'y' BraLen = '' while Go == 'y': BraLen += Tree[Posi] if Tree[Posi] == ',' or Tree[Posi] == ')': Go = 'n' Posi += 1 # print Clo,BraLen if float(BraLen[:-1]) == 0: DecAncLs.append(Clo) ###### else: DecTipLs.append(Clo) # print DecLs,DecAncLs if DecLs == []: NewDecom = 'n' elif DecTipLs != []: NewDecom = 'y' for Tip in DecTipLs: TipSeq = Clo2Seq[Tip] OriTu = Tip.split('Clu')[0] # TipMutC Anc = 'n' for Clo in Clo2Seq: if Clo != Tip: # and OriTu!=Clo: UniNum = Align.CountAdditionalMut(TipSeq, Clo2Seq[Clo]) if UniNum == 0: Anc = 'y' if Anc == 'y': RmDecom.append(Tip) else: NewDecom = 'anc' # NewDecom='anc' # for Dclo in DecLs: # if DecAncLs.count(Dclo)==0: NewDecom='y' # print Clo2Seq.keys() if RmDecom == []: NewClo2Seq_buil = no_back_para_mut_decomposed_seq else: NewCloDic = {} for Clo in Clo2Seq: if RmDecom.count(Clo) == 0: NewCloDic[Clo] = Clo2Seq[Clo] NewClo2Seq_buil = Align.UpMeg(NewCloDic, []) return NewDecom, RmDecom, NewClo2Seq_buil
def add_back_anc(self, Sub_seq_builder, All_seq_builder): Align = MegaAlignment() Ls, Sub = Align.name2seq(Sub_seq_builder) Ls, All = Align.name2seq(All_seq_builder) Clo2Seq = {} for Clo in All: if Sub.has_key(Clo) == True: Clo2Seq[Clo] = Sub[Clo] else: Clo2Seq[Clo] = All[Clo] Seq_Buil = Align.UpMeg(Clo2Seq, []) return Seq_Buil
def __init__(self, ini_seq_builder, v_obs, clone_frequencies, CNV, freq_cutoff): self.freq_cutoff = freq_cutoff self.Tu2CloFre = clone_frequencies self.CloFreCutOff = self.freq_cutoff self.v_obs = v_obs Align = MegaAlignment() self.clone_order, self.clone_seq = Align.name2seq(ini_seq_builder) self._CNV_file = CNV self.snv_num = len(self.clone_seq[self.clone_order[0]])
def __init__(self, ini_seq_builder, tsp_list, clone_frequencies, CNV, freq_cutoff): self.tsp_list = tsp_list self.freq_cutoff = freq_cutoff self.Tu2CloFre = clone_frequencies self.all_tsp = tsp_information(tsp_list) self.CloFreCutOff = self.freq_cutoff self.v_obs = self.all_tsp.tumor2alt_frequency() Align = MegaAlignment() self.clone_order, self.clone_seq = Align.name2seq(ini_seq_builder) self._CNV_file = CNV
def regress_cnv(self): Align = MegaAlignment() CloFreAna = CloneFrequencyAnalizer() self.Tumor2Clone_frequency = {} HitCloSeq_dic = {} self.tumor2CNVSNVposi = {} # print 'nnls removing SNV-CNVs' for tumor in self.v_obs: # print tumor v_obs_single = self.v_obs[tumor] v_obs_single_sub = [] Seq_dic_sub = {} RmSNVPosi = [] CNVls = self._CNV_file[tumor] Len = len(CNVls) c = 0 while c < Len: if CNVls[c] == 'normal': v_obs_single_sub.append(v_obs_single[c]) else: RmSNVPosi.append(c) c += 1 for Clo in self.ini_clone_order: NewSeq = '' OldSeq = self.ini_clone_seq[Clo] c = 0 while c < Len: if RmSNVPosi.count(c) == 0: NewSeq += OldSeq[c] c += 1 Seq_dic_sub[Clo] = NewSeq self.tumor2CNVSNVposi[tumor] = RmSNVPosi MutWildAlleleCount_noCNV = self.make_mut_wild_allele_count_noCNV( {}, self.ini_clone_order, Seq_dic_sub) #PreAbsCNV, clone_order, SNV_seq, Tu2CloFre Cmatrix_noCNV, Cmatrix_noCNV_dic = self.make_Min( self.ini_clone_order, Seq_dic_sub, MutWildAlleleCount_noCNV) self.Cmatrix_noCNV_mat = Cmatrix_noCNV self.Cmatrix_noCNV_dic = Cmatrix_noCNV_dic Clone2Freq = self.do_nnls0(Cmatrix_noCNV, self.ini_clone_order, v_obs_single_sub) self.Tumor2Clone_frequency['T-' + tumor] = Clone2Freq for Clo in Clone2Freq: if Clone2Freq[Clo] > 0: if HitCloSeq_dic.has_key('#' + Clo) != True: HitCloSeq_dic['#' + Clo] = self.ini_clone_seq['#' + Clo] self.hitclone_seq_builder = Align.UpMeg(HitCloSeq_dic, []) CloFreAna.save_frequency_table_to_file('Ini_freq.txt', self.Tumor2Clone_frequency, []) Align.save_mega_alignment_to_file('Ini.meg', self.hitclone_seq_builder)
def __init__(self, id0, seqs, PPcut): #seqs is list format of mega alignment self.PPcut=PPcut Align = MegaAlignment() tree_builder = MegaML() tree_analyzer = TreeAnalizer() self.InMeg = Align.AddNormal(seqs) status = tree_builder.do_mega_ml(self.InMeg, id0) if status == True: tree = tree_builder.newick_trees else: print 'failed to run megaML' self.Tree_rooted = tree_analyzer.RootTree(tree, 'Normal')
def _remove_redund_seqs(self, Meg): print 'removing redundant seqs...' Align = MegaAlignment() NameOrder, Name2Seq = Align.name2seq(Meg) out2 = ['#MEGA', '!Title SNVs;', '!Format datatype=dna;'] c = 0 Name2IdenLs = {} SeqNum = len(NameOrder) Len = len(Name2Seq[NameOrder[0]]) while c < SeqNum: Ref = NameOrder[c] RefSeq = Name2Seq[Ref] Name2IdenLs[Ref] = [Ref] Tc = 0 while Tc < SeqNum: Tar = NameOrder[Tc] TarSeq = Name2Seq[Tar] DifC = self._count_diff_num(RefSeq, TarSeq) if DifC == 0: Name2IdenLs[Ref].append(Tar) Tc += 1 c += 1 Done = [] for Name in Name2Seq: Code = Name in Done if Code != True: IdenLs = Name2IdenLs[Name] GoodName = '' for i in IdenLs: if GoodName == '': GoodName = i elif i == '#hg19': GoodName = i elif GoodName == '#hg19': pass elif i.find('Node') == -1 and i.find('Clu') == -1: GoodName = i elif GoodName.find('Node') == -1 and GoodName.find( 'Clu') == -1: pass elif GoodName.find('Node') != -1: GoodName = i elif i.find('Node') != -1: pass elif i.find('Clu') != -1 and GoodName.find( 'Clu') != -1 and i.find( 'REP') != -1 and GoodName.find('REP') == -1: GoodName = i else: pass out2 += [GoodName, Name2Seq[Name]] Done += IdenLs return out2
def __init__(self, seqs, num_support_position, Cell2PPls, initial_seq_builder, OutFileName): self.cut = num_support_position Align = MegaAlignment() self.ini_seqs_builder = seqs self.CellLs, self.Cell2Seq = Align.name2seq(seqs) self.SNVnum = len(self.Cell2Seq[self.CellLs[0]]) self.InMeg = Align.AddNormal(seqs) IniCellLs, self.Cell2iniSeq = Align.name2seq(initial_seq_builder) self.Cell2PPls = Cell2PPls self.out_file_name = OutFileName
def clone_to_tumor_phylogeny(self, OriginalNwk, Tu2CloFre, CloSeqLs): KeepLs = ['hg19'] Keep2TuLs = {'hg19': []} Align = MegaAlignment() CloOr, CloSeq = Align.name2seq(CloSeqLs) print Tu2CloFre for Tu in Tu2CloFre: CloFre = Tu2CloFre[Tu] CloLs = [] for Clo in CloFre: if CloFre[Clo] > 0: CloLs.append(Clo) LarClo = '' LarMut = 0 for Clo0 in CloLs: Seq0 = CloSeq['#' + Clo0] MutC = len(Align.GetMutPos(Seq0)) if MutC > LarMut: LarMut = MutC LarClo = Clo0 Keep = 'y' for Clo1 in CloLs: if Clo0 != Clo1: Seq1 = CloSeq['#' + Clo1] UniMutNum = 0 Len = len(Seq1) c = 0 while c < Len: if Seq0[c] == 'T' and Seq1[c] == 'A': UniMutNum += 1 c += 1 Pro = 1.0 * UniMutNum / Len if Pro < 0.05: Keep = 'n' if Keep == 'y': if KeepLs.count(Clo0) == 0: KeepLs.append(Clo0) Keep2TuLs[Clo0] = [] Keep2TuLs[Clo0].append(Tu) #KeepLs.append(LarClo) if KeepLs.count(LarClo) == 0: KeepLs.append(LarClo) Keep2TuLs[LarClo] = [] Keep2TuLs[LarClo].append(Tu) RmLs = [] for Clo in CloSeq: if KeepLs.count(Clo[1:]) == 0: RmLs.append(Clo[1:]) print 'remove ancestral clones', RmLs print 'tumor ls for each clone', Keep2TuLs Pruned = self.PruneTree(OriginalNwk, KeepLs) Pruned_Root = self.RootTree(Pruned) return Pruned_Root, Keep2TuLs
def __init__(self, seqs_with_ancestor, tsp_list, CNV_info, freq_cutoff, ReadCountTable): self.CutOff = freq_cutoff if seqs_with_ancestor != {}: Align = MegaAlignment() self.ini_seq_builder = seqs_with_ancestor self.ini_clone_order, self.ini_clone_seq = Align.name2seq( self.ini_seq_builder) self.tsp_list = tsp_list self.make_readcount() self._CNV_file = CNV_info self.ReadCountTable = ReadCountTable self.SNVnum = len(ReadCountTable[ReadCountTable.keys()[0]]) self.CNVnum = len(CNV_info[CNV_info.keys()[0]])
def compare_good_posi_number(self, Initial, After, IniSeq_buil, AftSeq_buil): IniCou = self.count_good_posi(Initial) AftCou = self.count_good_posi(After) Align = MegaAlignment() CloLs, IniSeq_dic = Align.name2seq(IniSeq_buil) CloLs, AftSeq_dic = Align.name2seq(AftSeq_buil) ShareIni = Align.GetSharePosi1(IniSeq_dic, 'A') ShareAft = Align.GetSharePosi1(AftSeq_dic, 'A') print IniCou, AftCou, len(ShareIni), len(ShareAft) if IniCou > AftCou or len(ShareAft) > len(ShareIni): AfterGood = 'n' else: AfterGood = 'y' return AfterGood
def find_new_clone(self, new_seq_buil, old_seq_buil): Align = MegaAlignment() Ls, New_dic = Align.name2seq(new_seq_buil) Ls, Old_dic = Align.name2seq(old_seq_buil) # print 'old list',Old_dic.keys(), '\nnew list',New_dic.keys() Iden = 'y' for Clo in New_dic: if Clo != '#hg19': NewSeq = New_dic[Clo] Redun = Align.find_redundant(NewSeq, Old_dic) if Redun == []: Iden = 'n' # print 'new seq',Clo return Iden
def Compute_PP(self): Align = MegaAlignment() tree_analyzer = TreeAnalizer() PP_builder = MegaPP() Input=self.Tree_rooted print 'input for inferring missing',Input Meg=self.InMeg NameOrder, self.Cell2megSeq=Align.name2seq_with_normal(Meg) id = 'All_alignment' status = PP_builder.do_mega_pp(self.InMeg, self.Tree_rooted, id) if status == True: self.Cell2PP = PP_builder.retrieve_pp_states() else: print 'failed to run megaPP'
def adjust_cell_genotype1(self): Align = MegaAlignment() tree_builder = MegaML() tree_analyzer = TreeAnalizer() status = tree_builder.do_mega_ml(self.InMeg, 'Noresun') if status == True: tree1 = tree_builder.newick_trees else: print('failed to run megaML') Tree_Rooted1 = tree_analyzer.RootTree_rootBottom(tree1, 'Normal') InferAncestor = MegaAncestor() InferAncestor.alignment_file = self.InMeg InferAncestor.input_tree_file = Tree_Rooted1 self.ancestor_states, self.offspring2ancestor, cell2code, self.code2cell = InferAncestor.retrieve_ancestor_states( ) ancestor2offspring, self.node2cellclade = InferAncestor.report_anc2dec_lin( ) for code in self.code2cell: if self.code2cell[code].find('Node_') == -1: self.node2cellclade[code] = [self.code2cell[code]] self.Cellclade_withSupport2SupportCount = self.count_support3() self.Clone2CellLs = self.get_clone3()
def finalize_results(self, decomposed_seq_builder, decomposed_Tumor2Clone_frequency, origianl_seq_builder, original_Tumor2Clone_frequency, REP): Align = MegaAlignment() Ls, DecomSeqDic = Align.name2seq(decomposed_seq_builder) # print Ls Ls, OriSeqDic = Align.name2seq(origianl_seq_builder) NewCloSeqDic = {} NewCloFre = {} # print decomposed_Tumor2Clone_frequency,original_Tumor2Clone_frequency for Tu in original_Tumor2Clone_frequency: if decomposed_Tumor2Clone_frequency.has_key(Tu) != True: CloFre = original_Tumor2Clone_frequency[Tu] for Clo in CloFre: if CloFre[Clo] > 0: NewCloSeqDic['#' + Clo] = OriSeqDic['#' + Clo] elif decomposed_Tumor2Clone_frequency[Tu] == {}: CloFre = original_Tumor2Clone_frequency[Tu] for Clo in CloFre: if CloFre[Clo] > 0: NewCloSeqDic['#' + Clo] = OriSeqDic['#' + Clo] else: CloFre0 = decomposed_Tumor2Clone_frequency[Tu] CloFre = {} for Clo in CloFre0: Fre = CloFre0[Clo] if Fre > 0: if (Clo.find('Clu') != -1 and Clo.find('REP') == -1) or Clo.find('REP' + str(REP - 1)) != -1: CloFre[Clo + 'REP' + str(REP)] = Fre NewCloSeqDic['#' + Clo + 'REP' + str(REP)] = DecomSeqDic['#' + Clo] else: CloFre[Clo] = Fre if OriSeqDic.has_key('#' + Clo) == True: NewCloSeqDic['#' + Clo] = OriSeqDic['#' + Clo] else: NewCloSeqDic['#' + Clo] = DecomSeqDic['#' + Clo] NewCloFre[Tu] = CloFre rename_seq_builder = Align.UpMeg(NewCloSeqDic, []) # open('AA','r').readlines() return rename_seq_builder, NewCloFre
def add_back_CNVSNV(self, DecomTu2Seq_builder_sub, CNV_information, original_seqs_builder_all, original_Tumor2Clone_frequency, tsp_list): all_tsp = tsp_information(tsp_list) v_obs = all_tsp.tumor2alt_frequency() Seq_all_dic = {} Align = MegaAlignment() Original_clols, Original_clodic_all = Align.name2seq( original_seqs_builder_all) for Tumor in DecomTu2Seq_builder_sub: Seq_builder_sub = DecomTu2Seq_builder_sub[Tumor] if Seq_builder_sub != []: SNVfre_list = v_obs[Tumor] CloLs, Clo2Seq = Align.name2seq(Seq_builder_sub) CNVinfo = CNV_information[Tumor] Len = len(CNVinfo) # print Tumor, Clo2Seq.keys() for Clo in Clo2Seq: Seq_sub = Clo2Seq[Clo] c_seq = 0 c_all = 0 Seq_all = '' while c_all < Len: if CNVinfo[c_all] == 'normal': Seq_all += Seq_sub[c_seq] c_seq += 1 else: if SNVfre_list[c_all] == 0: Seq_all += 'A' else: Seq_all += '?' c_all += 1 if Original_clodic_all.has_key(Clo) == True: Seq_all_dic[Clo] = Original_clodic_all[Clo] else: Seq_all_dic[Clo] = Seq_all else: CloFre = original_Tumor2Clone_frequency['T-' + Tumor] for Clo in CloFre: if CloFre[Clo] > 0: if Seq_all_dic.has_key('#' + Clo) != True: Seq_all_dic['#' + Clo] = Original_clodic_all['#' + Clo] decom_all_seq_builder = Align.UpMeg(Seq_all_dic, []) return decom_all_seq_builder