--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libs/mapping_and_assembly_hybrid.py	Tue Nov 06 09:45:57 2018 -0500
@@ -0,0 +1,564 @@
+import os,sys,glob,time,itertools,subprocess
+from collections import OrderedDict
+from Initial_Conditions import phase1
+from Initial_Conditions import phase2
+from Initial_Conditions import phaseO
+from Initial_Conditions import sero
+from distutils.version import LooseVersion
+
+import csv
+from subprocess import check_output
+
+
+def xml_parse_score_comparision_seqsero(xmlfile):
+  #used to do seqsero xml analysis
+  from Bio.Blast import NCBIXML
+  handle=open(xmlfile)
+  handle=NCBIXML.parse(handle)
+  handle=list(handle)
+  List=[]
+  List_score=[]
+  List_ids=[]
+  for i in range(len(handle)):
+    if len(handle[i].alignments)>0:
+      for j in range(len(handle[i].alignments)):
+        score=0
+        ids=0
+        List.append(handle[i].query.strip()+"___"+handle[i].alignments[j].hit_def)
+        for z in range(len(handle[i].alignments[j].hsps)):
+          if "last" in handle[i].query or "first" in handle[i].query:
+            score+=handle[i].alignments[j].hsps[z].bits
+            ids+=float(handle[i].alignments[j].hsps[z].identities)/handle[i].query_length
+          else:
+            if handle[i].alignments[j].hsps[z].align_length>=30:
+              #for the long alleles, filter noise parts
+              score+=handle[i].alignments[j].hsps[z].bits
+              ids+=float(handle[i].alignments[j].hsps[z].identities)/handle[i].query_length
+        List_score.append(score)
+        List_ids.append(ids)
+  temp=zip(List,List_score,List_ids)
+  Final_list=sorted(temp, key=lambda d:d[1], reverse = True)
+  return Final_list
+
+
+def Uniq(L,sort_on_fre="none"): #return the uniq list and the count number
+  Old=L
+  L.sort()
+  L = [L[i] for i in range(len(L)) if L[i] not in L[:i]]
+  count=[]
+  for j in range(len(L)):
+    y=0
+    for x in Old:
+      if L[j]==x:
+        y+=1
+    count.append(y)
+  if sort_on_fre!="none":
+    d=zip(*sorted(zip(count, L)))
+    L=d[1]
+    count=d[0]
+  return (L,count)
+
+
+def judge_fliC_or_fljB_from_head_tail_for_one_contig(nodes_vs_score_list):
+  #used to predict it's fliC or fljB for one contig, based on tail and head score, but output the score difference,if it is very small, then not reliable, use blast score for whole contig to test
+  #this is mainly used for 
+  a=nodes_vs_score_list
+  fliC_score=0
+  fljB_score=0
+  for z in a:
+    if "fliC" in z[0]:
+      fliC_score+=z[1]
+    elif "fljB" in z[0]:
+      fljB_score+=z[1]
+  if fliC_score>=fljB_score:
+    role="fliC"
+  else:
+    role="fljB"
+  return (role,abs(fliC_score-fljB_score))
+
+def judge_fliC_or_fljB_from_whole_contig_blast_score_ranking(node_name,Final_list_passed):
+  #used to predict contig is fliC or fljB, if the differnce score value on above head_and_tail is less than 10 (quite small)
+  #also used when no head or tail got blasted score for the contig
+  role=""
+  for z in Final_list_passed:
+    if node_name in z[0]:
+      role=z[0].split("_")[0]
+      break
+  return role
+
+
+def fliC_or_fljB_judge_from_head_tail_sequence(nodes_list,tail_head_list,Final_list_passed):
+  #nodes_list is the c created by c,d=Uniq(nodes) in below function
+  first_target=""
+  role_list=[]
+  for x in nodes_list:
+    a=[]
+    role=""
+    for y in tail_head_list:
+      if x in y[0]:
+        a.append(y)
+    if len(a)==4:
+      #compare two heads (37 > 30)
+      #four contigs, most perfect assembly, high quality
+      """
+      for z in a:
+        if "fliC_first_37" in z[0]:
+          t1=z[1]
+        elif "fljB_first_37" in z[0]:
+          t2=z[1]
+      if t1>=t2:
+        role="fliC"
+      else:
+        role="fljB"
+      """
+      role,diff=judge_fliC_or_fljB_from_head_tail_for_one_contig(a)
+      if diff<20:
+        role=judge_fliC_or_fljB_from_whole_contig_blast_score_ranking(x,Final_list_passed)
+    elif len(a)==3:
+      """
+      #compare the number, because hybrid problem
+      temp=[]
+      for z in a:
+        temp.append(z[0].split("_")[0])
+      m,n=Uniq(temp)#only two choices in m or n
+      if n[0]>n[1]:
+        role=m[0]
+      else:
+        role=m[1]
+      """
+      ###however, if the one with highest score is the fewer one, compare their accumulation score
+      role,diff=judge_fliC_or_fljB_from_head_tail_for_one_contig(a)
+      if diff<20:
+        role=judge_fliC_or_fljB_from_whole_contig_blast_score_ranking(x,Final_list_passed)
+      ###end of above score comparison
+    elif len(a)==2:
+      #must on same node, if not, then decide with unit blast score, blast-score/length_of_special_sequence(30 or 37)
+      temp=[]
+      for z in a:
+        temp.append(z[0].split("_")[0])
+      m,n=Uniq(temp)#should only have one choice, but weird situation might occur too
+      if len(m)==1:
+        pass
+      else:
+        pass
+        #print "head and tail not belong to same role, now let's guess based on maximum likelihood"
+      role,diff=judge_fliC_or_fljB_from_head_tail_for_one_contig(a)
+      if diff<20:
+        role=judge_fliC_or_fljB_from_whole_contig_blast_score_ranking(x,Final_list_passed)
+        """
+        max_unit_score=0
+        for z in a:
+          unit_score=z[-1]/int(z[0].split("__")[1])
+          if unit_score>=max_unit_score:
+            role=z[0].split("_")[0]
+            max_unit_score=unit_score
+        """
+        ###need to desgin a algorithm to guess most possible situation for nodes_list, See the situations of test evaluation
+    elif len(a)==1:
+      #that one
+      role,diff=judge_fliC_or_fljB_from_head_tail_for_one_contig(a)
+      if diff<20:
+        role=judge_fliC_or_fljB_from_whole_contig_blast_score_ranking(x,Final_list_passed)
+      #role=a[0][0].split("_")[0]
+      #need to evaluate, in future, may set up a cut-off, if not met, then just find Final_list_passed best match,like when "a==0"
+    else:#a==0
+      #use Final_list_passed best match
+      for z in Final_list_passed:
+        if x in z[0]:
+          role=z[0].split("_")[0]
+          break
+    #print x,role,len(a)
+    role_list.append((role,x))
+  if len(role_list)==2:
+    if role_list[0][0]==role_list[1][0]:#this is the most cocmmon error, two antigen were assigned to same phase
+      #just use score to do a final test
+      role_list=[]
+      for x in nodes_list: 
+        role=judge_fliC_or_fljB_from_whole_contig_blast_score_ranking(x,Final_list_passed)
+        role_list.append((role,x))
+  return role_list
+
+def decide_contig_roles_for_H_antigen(Final_list):
+  #used to decide which contig is FliC and which one is fljB
+  contigs=[]
+  Final_list_passed=[x for x in Final_list if float(x[0].split("_cov_")[1])>=3.5 and (x[1]>=int(x[0].split("__")[1]) or x[1]>=int(x[0].split("___")[1].split("_")[3]))]
+  nodes=[]
+  for x in Final_list_passed:
+    if x[0].startswith("fl") and "last" not in x[0] and "first" not in x[0]:
+      nodes.append(x[0].split("___")[1].strip())
+  c,d=Uniq(nodes)#c is node_list
+  #print c
+  tail_head_list=[x for x in Final_list if ("last" in x[0] or "first" in x[0])]
+  roles=fliC_or_fljB_judge_from_head_tail_sequence(c,tail_head_list,Final_list_passed)
+  return roles
+
+def Combine(b,c):
+  fliC_combinations=[]
+  fliC_combinations.append(",".join(c))
+  temp_combinations=[]
+  for i in range(len(b)):
+    for x in itertools.combinations(b,i+1):
+      temp_combinations.append(",".join(x))
+  for x in temp_combinations:
+    temp=[]
+    for y in c:
+      temp.append(y)
+    temp.append(x)
+    temp=",".join(temp)
+    temp=temp.split(",")
+    temp.sort()
+    temp=",".join(temp)
+    fliC_combinations.append(temp)
+  return fliC_combinations
+
+def decide_O_type_and_get_special_genes(Final_list):
+  #decide O based on Final_list
+  O_choice="?"
+  O_list=[]
+  special_genes=[]
+  Final_list_passed=[x for x in Final_list if float(x[0].split("_cov_")[1])>=3.5 and (x[1]>=int(x[0].split("__")[1]) or x[1]>=int(x[0].split("___")[1].split("_")[3]))]
+  nodes=[]
+  for x in Final_list_passed:
+    if x[0].startswith("O-"):
+      nodes.append(x[0].split("___")[1].strip())
+    elif not x[0].startswith("fl"):
+      special_genes.append(x)
+  #print "special_genes:",special_genes
+  c,d=Uniq(nodes)
+  #print "potential O antigen contig",c
+  final_O=[]
+  O_nodes_list=[]
+  for x in c:#c is the list for contigs
+    temp=0
+    for y in Final_list_passed:
+      if x in y[0] and y[0].startswith("O-"):
+        final_O.append(y)
+        break
+  ### O contig has the problem of two genes on same contig, so do additional test
+  potenial_new_gene=""
+  for x in final_O:
+    pointer=0 #for genes merged or not
+    #not consider O-1,3,19_not_in_3,10, too short compared with others
+    if "O-1,3,19_not_in_3,10" not in x[0] and int(x[0].split("__")[1].split("___")[0])+800 <= int(x[0].split("length_")[1].split("_")[0]):#gene length << contig length; for now give 300*2 (for secureity can use 400*2) as flank region
+      pointer=x[0].split("___")[1].strip()#store the contig name
+      print pointer
+    if pointer!=0:#it has potential merge event
+      for y in Final_list:
+        if pointer in y[0] and y not in final_O and (y[1]>=int(y[0].split("__")[1].split("___")[0])*1.5 or (y[1]>=int(y[0].split("__")[1].split("___")[0])*y[2] and y[1]>=400)):#that's a realtively strict filter now; if passed, it has merge event and add one more to final_O
+          potenial_new_gene=y
+          print potenial_new_gene
+          break
+  if potenial_new_gene!="":
+    print "two differnt genes in same contig, fix it for O antigen"
+    final_O.append(potenial_new_gene)
+  ### end of the two genes on same contig test
+  if len(final_O)==0:
+    #print "$$$No Otype, due to no hit"#may need to be changed
+    O_choice="-"
+  else:
+    O_list=[]
+    for x in final_O:
+      O_list.append(x[0].split("__")[0])
+      if not "O-1,3,19_not_in_3,10__130" in x[0]:#O-1,3,19_not_in_3,10 is too small, which may affect further analysis
+        O_nodes_list.append(x[0].split("___")[1])
+    ### special test for O9,46 and O3,10 family
+    if "O-9,46_wbaV" in O_list:#not sure should use and float(O9_wbaV)/float(num_1) > 0.1
+      if "O-9,46_wzy" in O_list:#and float(O946_wzy)/float(num_1) > 0.1
+        O_choice="O-9,46"
+        #print "$$$Most possilble Otype:  O-9,46"
+      elif "O-9,46,27_partial_wzy" in O_list:#and float(O94627)/float(num_1) > 0.1
+        O_choice="O-9,46,27"
+        #print "$$$Most possilble Otype:  O-9,46,27"
+      else:
+        O_choice="O-9"#next, detect O9 vs O2?
+        O2=0
+        O9=0
+        for z in special_genes:
+          if "tyr-O-9" in z[0]:
+            O9=z[1]
+          elif "tyr-O-2" in z[0]:
+            O2=z[1]
+        if O2>O9:
+          O_choice="O-2"
+        elif O2<O9:
+          pass
+        else:
+          pass
+          #print "$$$No suitable one, because can't distinct it's O-9 or O-2, but O-9 has a more possibility."
+    elif ("O-3,10_wzx" in O_list) and ("O-9,46_wzy" in O_list):#and float(O310_wzx)/float(num_1) > 0.1 and float(O946_wzy)/float(num_1) > 0.1
+      if "O-3,10_not_in_1,3,19" in O_list:#and float(O310_no_1319)/float(num_1) > 0.1
+        O_choice="O-3,10"
+        #print "$$$Most possilble Otype:  O-3,10 (contain O-3,10_not_in_1,3,19)"
+      else:
+        O_choice="O-1,3,19"
+        #print "$$$Most possilble Otype:  O-1,3,19 (not contain O-3,10_not_in_1,3,19)"
+    ### end of special test for O9,46 and O3,10 family
+    else:
+      try: 
+        max_score=0
+        for x in final_O:
+          if x[1]>=max_score:
+            max_score=x[1]
+            O_choice=x[0].split("_")[0]
+        if O_choice=="O-1,3,19":
+          O_choice=final_O[1][0].split("_")[0]
+        #print "$$$Most possilble Otype: ",O_choice
+      except:
+        pass
+        #print "$$$No suitable Otype, or failure of mapping (please check the quality of raw reads)"
+  #print "O:",O_choice,O_nodes_list
+  return O_choice,O_nodes_list,special_genes,final_O
+
+def seqsero_from_formula_to_serotypes(Otype,fliC,fljB,special_gene_list):
+  #like test_output_06012017.txt
+  #can add more varialbles like sdf-type, sub-species-type in future (we can conclude it into a special-gene-list)
+  from Initial_Conditions import phase1
+  from Initial_Conditions import phase2
+  from Initial_Conditions import phaseO
+  from Initial_Conditions import sero
+  seronames=[]
+  for i in range(len(phase1)):
+    fliC_combine=[]
+    fljB_combine=[]
+    if phaseO[i]==Otype:
+      ### for fliC, detect every possible combinations to avoid the effect of "["
+      if phase1[i].count("[")==0:
+        fliC_combine.append(phase1[i])
+      elif phase1[i].count("[")>=1:
+        c=[]
+        b=[]
+        if phase1[i][0]=="[" and phase1[i][-1]=="]" and phase1[i].count("[")==1:
+          content=phase1[i].replace("[","").replace("]","")
+          fliC_combine.append(content)
+          fliC_combine.append("-")
+        else:
+          for x in phase1[i].split(","):
+            if "[" in x:
+              b.append(x.replace("[","").replace("]",""))
+            else:
+              c.append(x)
+          fliC_combine=Combine(b,c) #Combine will offer every possible combinations of the formula, like f,[g],t: f,t  f,g,t
+      ### end of fliC "[" detect
+      ### for fljB, detect every possible combinations to avoid the effect of "["
+      if phase2[i].count("[")==0:
+        fljB_combine.append(phase2[i])
+      elif phase2[i].count("[")>=1:
+        d=[]
+        e=[]
+        if phase2[i][0]=="[" and phase2[i][-1]=="]" and phase2[i].count("[")==1:
+          content=phase2[i].replace("[","").replace("]","")
+          fljB_combine.append(content)
+          fljB_combine.append("-")
+        else:
+          for x in phase2[i].split(","):
+            if "[" in x:
+              d.append(x.replace("[","").replace("]",""))
+            else:
+              e.append(x)
+          fljB_combine=Combine(d,e)
+      ### end of fljB "[" detect
+      new_fliC=fliC.split(",") #because some antigen like r,[i] not follow alphabetical order, so use this one to judge and can avoid missings
+      new_fliC.sort()
+      new_fliC=",".join(new_fliC)
+      new_fljB=fljB.split(",")
+      new_fljB.sort()
+      new_fljB=",".join(new_fljB)
+      if (new_fliC in fliC_combine or fliC in fliC_combine) and (new_fljB in fljB_combine or fljB in fljB_combine):
+        seronames.append(sero[i])
+  #analyze seronames
+  if len(seronames)==0:
+    seronames=["N/A (The predicted antigenic profile does not exist in the White-Kauffmann-Le Minor scheme)"]
+  star=""
+  star_line=""
+  if len(seronames)>1:#there are two possible predictions for serotypes
+    star="*"
+    star_line="The predicted serotypes share the same general formula:\t"+Otype+":"+fliC+":"+fljB+"\n"##
+  print "\n"
+  predict_form=Otype+":"+fliC+":"+fljB#
+  predict_sero=(" or ").join(seronames)
+  ###special test for Enteritidis
+  if predict_form=="9:g,m:-":
+    sdf="-"
+    for x in special_gene_list:
+      if x[0].startswith("sdf"):
+        sdf="+"
+    predict_form=predict_form+"\nSdf prediction:"+sdf
+    if sdf=="-":
+      star="*"
+      star_line="Additional characterization is necessary to assign a serotype to this strain.  Commonly circulating strains of serotype Enteritidis are sdf+, although sdf- strains of serotype Enteritidis are known to exist. Serotype Gallinarum is typically sdf- but should be quite rare. Sdf- strains of serotype Enteritidis and serotype Gallinarum can be differentiated by phenotypic profile or genetic criteria.\n"#+##
+      predict_sero="See comments below"
+  ###end of special test for Enteritidis
+  elif predict_form=="4:i:-":
+    predict_sero="potential monophasic variant of Typhimurium"
+  elif predict_form=="4:r:-":
+    predict_sero="potential monophasic variant of Heidelberg"
+  elif predict_form=="4:b:-":
+    predict_sero="potential monophasic variant of Paratyphi B"
+  elif predict_form=="8:e,h:1,2":
+    predict_sero="Newport"
+    star="*"
+    star_line="Serotype Bardo shares the same antigenic profile with Newport, but Bardo is exceedingly rare."
+  claim="The serotype(s) is/are the only serotype(s) with the indicated antigenic profile currently recognized in the Kauffmann White Scheme.  New serotypes can emerge and the possibility exists that this antigenic profile may emerge in a different subspecies.  Identification of strains to the subspecies level should accompany serotype determination; the same antigenic profile in different subspecies is considered different serotypes."##
+  if "N/A" in predict_sero:
+    claim=""
+  if "Typhimurium" in predict_sero or predict_form=="4:i:-":
+    normal=0
+    mutation=0
+    for x in special_gene_list:
+      if "oafA-O-4_full" in x[0]:
+        normal=x[1]
+      elif "oafA-O-4_5-" in x[0]:
+        mutation=x[1]
+    if normal>mutation:
+      #print "$$$Typhimurium"
+      pass
+    elif normal<mutation:
+      predict_sero=predict_sero.strip()+"(O5-)"
+      star="*"#
+      star_line="Detected the deletion of O5-."
+      #print "$$$Typhimurium_O5-"
+    else:
+      #print "$$$Typhimurium, even no 7 bases difference"
+      pass
+  return predict_form,predict_sero,star,star_line,claim
+
+def main():
+  database=sys.argv[1]#used to extract reads
+  mapping_mode=sys.argv[2]#mem or sampe
+  threads=sys.argv[3]
+  for_fq=sys.argv[4]
+  rev_fq=sys.argv[5]
+  current_time=time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime())
+  sam=for_fq+".sam"
+  bam=for_fq+".bam"
+  sorted_bam=for_fq+"_sorted.bam"
+  mapped_fq1=for_fq+"_mapped.fq"
+  mapped_fq2=rev_fq+"_mapped.fq"
+  combined_fq=for_fq+"_combined.fq"
+  for_sai=for_fq+".sai"
+  rev_sai=rev_fq+".sai"
+  print "building database..."
+  #os.system("bwa index "+database+ " 2> /dev/null")
+  os.system("bwa index "+database+ " 2>> data_log.txt ")
+  print "mapping..."
+  if mapping_mode=="mem":
+    os.system("bwa mem -t "+threads+" "+database+" "+for_fq+" "+rev_fq+" > "+sam+ " 2>> data_log.txt")
+  elif mapping_mode=="sam":
+    os.system("bwa aln -t "+threads+" "+database+" "+for_fq+" > "+for_sai+ " 2>> data_log.txt")
+    os.system("bwa aln -t "+threads+" "+database+" "+rev_fq+" > "+rev_sai+ " 2>> data_log.txt")
+    os.system("bwa sampe "+database+" "+for_sai+" "+ rev_sai+" "+for_fq+" "+rev_fq+" > "+sam+ " 2>> data_log.txt")
+  os.system("samtools view -@ "+threads+" -F 4 -Sbh "+sam+" > "+bam)
+  os.system("samtools view -@ "+threads+" -h -o "+sam+" "+bam)
+  ### check the version of samtools then use differnt commands
+  samtools_version=subprocess.Popen(["samtools"],stdout=subprocess.PIPE,stderr=subprocess.PIPE)
+  out, err = samtools_version.communicate()
+  version = err.split("ersion:")[1].strip().split(" ")[0].strip()
+  print "check samtools version:",version
+  if LooseVersion(version)<=LooseVersion("1.2"):
+    os.system("samtools sort -@ "+threads+" -n "+bam+" "+for_fq+"_sorted")
+  else:
+    os.system("samtools sort -@ "+threads+" -n "+bam+" >"+sorted_bam)
+  ### end of samtools version check and its analysis
+  os.system("bamToFastq -i "+sorted_bam+" -fq "+combined_fq)
+  os.system("bamToFastq -i "+sorted_bam+" -fq "+mapped_fq1+" -fq2 "+mapped_fq2 + " 2>> data_log.txt")#2> /dev/null if want no output
+  outdir=current_time+"_temp"
+  print "assembling..."
+  if int(threads)>4:
+    t="4"
+  else:
+    t=threads
+  os.system("spades.py --careful --pe1-s "+combined_fq+" --pe1-1 "+mapped_fq1+" --pe1-2 "+mapped_fq2+" -t "+t+" -o "+outdir+ " >> data_log.txt 2>&1")
+  new_fasta=for_fq+"_"+database+"_"+mapping_mode+".fasta"
+  os.system("mv "+outdir+"/contigs.fasta "+new_fasta+ " 2> /dev/null")
+  #os.system("mv "+outdir+"/scaffolds.fasta "+new_fasta+ " 2> /dev/null") contigs.fasta
+  os.system("rm -rf "+outdir+ " 2> /dev/null")
+  ### begin blast
+  print "blasting..."
+  print "\n"
+  xmlfile=for_fq+"-extracted_vs_"+database+"_"+mapping_mode+".xml"
+  os.system('makeblastdb -in '+new_fasta+' -out '+new_fasta+'_db '+'-dbtype nucl >> data_log.txt 2>&1') #temp.txt is to forbid the blast result interrupt the output of our program###1/27/2015
+  print check_output("blastn -word_size 10 -query "+database+" -db "+new_fasta+"_db -out "+xmlfile+" -outfmt 5 >> data_log.txt 2>&1", shell=True)###1/27/2015
+  Final_list=xml_parse_score_comparision_seqsero(xmlfile)
+  Final_list_passed=[x for x in Final_list if float(x[0].split("_cov_")[1])>=3.5 and (x[1]>=int(x[0].split("__")[1]) or x[1]>=int(x[0].split("___")[1].split("_")[3]))]
+  fliC_choice="-"
+  fljB_choice="-"
+  fliC_contig="NA"
+  fljB_contig="NA"
+  fliC_length=0 #can be changed to coverage in future
+  fljB_length=0 #can be changed to coverage in future
+  O_choice=""#no need to decide O contig for now, should be only one
+  O_choice,O_nodes,special_gene_list,O_nodes_roles=decide_O_type_and_get_special_genes(Final_list)#decide the O antigen type and also return special-gene-list for further identification
+  O_choice=O_choice.split("-")[-1].strip()
+  H_contig_roles=decide_contig_roles_for_H_antigen(Final_list)#decide the H antigen contig is fliC or fljB
+  log_file=open("SeqSero_hybrid_assembly_log.txt","a")
+  print "O_contigs:"
+  log_file.write("O_contigs:\n")
+  for x in O_nodes_roles:
+    if "O-1,3,19_not_in_3,10" not in x[0]:#O-1,3,19_not_in_3,10 is just a small size marker
+      print x[0].split("___")[-1],x[0].split("__")[0],"blast score:",x[1],"identity%:",str(round(x[2]*100,2))+"%"
+      log_file.write(x[0].split("___")[-1]+" "+x[0].split("__")[0]+" "+"blast score: "+str(x[1])+"identity%:"+str(round(x[2]*100,2))+"%"+"\n")
+  print "H_contigs:"
+  log_file.write("H_contigs:\n")
+  H_contig_stat=[]
+  for i in range(len(H_contig_roles)):
+    x=H_contig_roles[i]
+    a=0
+    for y in Final_list_passed:
+      if x[1] in y[0] and y[0].startswith(x[0]):
+        if "first" in y[0] or "last" in y[0]: #this is the final filter to decide it's fliC or fljB, if can't pass, then can't decide
+          for y in Final_list_passed: #it's impossible to has the "first" and "last" allele as prediction, so re-do it
+            if x[1] in y[0]:#it's very possible to be third phase allele, so no need to make it must be fliC or fljB
+              print x[1],"can't_decide_fliC_or_fljB",y[0].split("_")[1],"blast_score:",y[1],"identity%:",str(round(y[2]*100,2))+"%"
+              log_file.write(x[1]+" "+x[0]+" "+y[0].split("_")[1]+" "+"blast_score: "+str(y[1])+" identity%:"+str(round(y[2]*100,2))+"%"+"\n")
+              H_contig_roles[i]="can't decide fliC or fljB, may be third phase"
+              break
+        else:
+          print x[1],x[0],y[0].split("_")[1],"blast_score:",y[1],"identity%:",str(round(y[2]*100,2))+"%"
+          log_file.write(x[1]+" "+x[0]+" "+y[0].split("_")[1]+" "+"blast_score: "+str(y[1])+" identity%:"+str(round(y[2]*100,2))+"%"+"\n")
+        break
+  for x in H_contig_roles:
+    #if multiple choices, temporately select the one with longest length for now, will revise in further change
+    if "fliC" == x[0] and int(x[1].split("_")[3])>=fliC_length and x[1] not in O_nodes:#remember to avoid the effect of O-type contig, so should not in O_node list
+      fliC_contig=x[1]
+      fliC_length=int(x[1].split("_")[3])
+    elif "fljB" == x[0] and int(x[1].split("_")[3])>=fljB_length and x[1] not in O_nodes:
+      fljB_contig=x[1]
+      fljB_length=int(x[1].split("_")[3])
+  for x in Final_list_passed:
+    if fliC_choice=="-" and "fliC_" in x[0] and fliC_contig in x[0] :
+      fliC_choice=x[0].split("_")[1]
+    elif fljB_choice=="-" and "fljB_" in x[0] and fljB_contig in x[0]:
+      fljB_choice=x[0].split("_")[1]
+    elif fliC_choice!="-" and fljB_choice!="-":
+      break
+  # print "\n"
+  # print "SeqSero Input files:",for_fq,rev_fq
+  # print "Most possible O antigen:",O_choice
+  # print "Most possible H1 antigen:",fliC_choice
+  # print "Most possible H2 antigen:",fljB_choice
+
+
+
+  #print Final_list
+  ###output
+  predict_form,predict_sero,star,star_line,claim=seqsero_from_formula_to_serotypes(O_choice,fliC_choice,fljB_choice,special_gene_list)
+  
+  result = OrderedDict(sample_name=for_fq.split('_')[0],
+                O_antigen_prediction=O_choice,
+                H1_antigen_prediction=fliC_choice,
+                H2_antigen_prediction=fljB_choice,
+                predicted_antigenic_profile=predict_form,
+                predicted_serotypes=predict_sero)
+
+  print result
+
+  with open("Seqsero_result.tsv", 'w') as results_file:
+    wtr = csv.DictWriter(delimiter='\t', fieldnames=result.keys())
+  
+  # new_file=open("Seqsero_result.txt","w")
+  # new_file.write("Input files:\t"+for_fq+" "+rev_fq+"\n"+"O antigen prediction:\t"+"O-"+O_choice+"\n"+"H1 antigen prediction(fliC):\t"+fliC_choice+"\n"+"H2 antigen prediction(fljB):\t"+fljB_choice+"\n"+"Predicted antigenic profile:\t"+predict_form+"\n"+"Predicted serotype(s):\t"+predict_sero+star+"\n"+star+star_line+claim+"\n")#+##
+  # new_file.close()
+  # os.system("cat Seqsero_result.txt")
+
+if __name__ == '__main__':
+  main()