#rR gscope_cilio.tcl

#rR Attention : Odile a triché elle a défini des "Clades" Excavata et Archaeplastida MAIS
#rR             ces termes n'existent pas dans TaxUniprot
#rR             J'ai fait une petite magouille pour la proc JeSuisTonAncetre (utilisé par taxobla pour protall) 
#rR             Sinon ailleurs on ne devrait pas en avoir besoin. 

#rR petite histoire des proteome de OrthoInspector:
#rR ET C'EST PAS FINI !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#rR Tout ce qui suit risque d'être faux car il y a maintenant le proteome que Yannis Nevers a ramené 
#rR donc Attention il y a plein de procédures ...OrthoInspector... qui se transforme en ...Yannis...
#rR et ... je répète ... ne vous fiez pas trop aux commentaires !!
#rR .... et 2014/07 Yannis a tout mis dans une base de données docn tot ce qui suit est très approximatif !!! 

#rR Benjamin nous fournit
#rR ********* ne sert pas
#rR 1: (mais il ne sert pas pour le moment je le laisse quand même ici pour l'explication)
#rR  /dimo/data/orthoinspector_eukaryota_2011_12/orthoinspector_v2_database_dumps_raw_not_pgsql_7-12-2012.tar.gz
#rR - ce fichier fait 34 GO
#rR - je le decompresse dans /biolo/orthoinpector/DataOrthoInspector/database_dumps/
#rR ********* fin ne sert pas 

#rR /dimo/data/orthoinspector_eukaryota_2011_12/Orthoinspector_v2_project_data_backup.tar.gz
#rR - ce fichier fait 5.5 GO
#rR - je le decompresse dans /biolo/orthoinpector/DataOrthoInspector/Orthoinspector_v2/
#rR - il contient essentiellement bacteria_archae/ et eukaryota/ qui nous intéresse ici.
#rR - eukaryota/ contient plein de renseignements utiles concernant les organismes et surtout
#rR - all/ contient 261 fasta les protéomes qui nous intéressent.
#rR ATTENTION il y a plein de fichiers qui n'ont pas de CR à la fin. 
#rR Je les ai modifiés avec la proc ci-dessous.
#rR J'ai aussi changé cavia_porcellus_9823_23_11_11_merged.fasta
#rR                en cavia_porcellus_10141_23_11_11_merged.fasta
#rR    car 9823 c'est Sus scrofa !!! ???
#rR Je me suis servi de CreeUneBanqueBlastAvecOrthoInspector pour créer les proteomes 
#rR    dans /biolo/orthoinpector/DataOrthoInspector/Orthoinspector_v2/eukaryota/proteomes
  
#rR Pour CilioCarta 2014/07/01 :
#rR  si on refait un nouveau projet il faut 
#rR  - InformeIdEtAcPourTous
#rR  - InformeValiDEPourTous
#rR  - InformeValiGNPourTous
#rR  - InformeIdOiAndAcOiPourTous
#rR  - InformeIdRefAndAcRefPourTous
#rR Faire
#rR  - BlastPPourTous   (penser à mettre BlastParameters.txt dans CilioCarta/blastp) 
#rR  - DbClustalPourTous All Ortholog (ATTENTION obsolète: Yannis créée lui-même les tfasdecopains 2014/07)
#rR  - LeonEtMacsimPourTous


#rR ********* ce paragraphe est obsolète (c'était un essai avec Kirsley)
#rR pour initialiser CilioCarta : (Raymond le 2014/03/28)
#rR Kirsley m'a fourni les fichiers
#rR 101_ciliopathies_desc.csv        qui donne des infos generales
#rR 101_ciliopathies_mapping_ids.tsv pour la correspondance ensg enst ensp genename uniprotId
#rR 101_ciliopathies_pep.fasta       sequences proteiques
#rR 101_ciliopathies_gene.2.fasta    sequences des transcrits correpondants

#rR j'ai commence par integrer tout ca.
#rR Ca s'interroge par CilioDesc Qui Quoi, CilioMappping Qui Quoi, CilioPep Qui Quoi
#rR J'ai créé CilioCarta101.fasta
#rR puis le projet Gscope  
#rR et j'integre le tout avec InformeCilioCarta
#rR ********* fin paragraphe obsolète

proc CilioPathyGenes {{Qui ""} {Quoi ""}} {
    global CPG
    if {[info exists CPG($Qui,$Quoi)]} { return $CPG($Qui,$Quoi) }
    if {[info exists CPG("EstCharge")]} { return "" }
    set CPG("EstCharge") 1
    
    #set FichierCsv "[GscopeDatabaseDir EHomsa]/fiches/ciliopathy_genes_v1_sans_cr.csv"
    set FichierCsv "[GscopeDatabaseDir EHomsa]/fiches/1869CilioPathyGenes_20170510.csv"

    set PremiereFois 1
    foreach Ligne [LesLignesDuFichier $FichierCsv] {
	regsub -all {\"} $Ligne "" Ligne
	if {$PremiereFois} {
	    regsub -all " " $Ligne "_" Ligne
	    set LesHeaders [split $Ligne ";"]
	    set PremiereFois 0
	    continue
	}
	set LesMots [split $Ligne ";"]
	set Gs [lindex $LesMots 1]
	regsub -all {[ \?]} $Gs "" Gns
	set LesGn [split $Gns "/"]
	foreach H $LesHeaders V $LesMots {
	    foreach Gn $LesGn {
		lappend CPG(ListOf,Gn) $Gn
		lappend CPG($Gn,$H) $V
	    }
	}
    }
    
    set CPG(ListOf,Gn) [lsort -unique $CPG(ListOf,Gn)]
    return [CilioPathyGenes $Qui $Quoi]
}

proc CilioPathyGenesOLD {{Qui ""} {Quoi ""}} {
    global CPG
    if {[info exists CPG($Qui,$Quoi)]} { return $CPG($Qui,$Quoi) }
    if {[info exists CPG("EstCharge")]} { return "" }
    set CPG("EstCharge") 1
    
    set FichierCsv "[GscopeDatabaseDir EHomsa]/fiches/ciliopathy_genes_v1_sans_cr.csv"

    set PremiereFois 1
    foreach Ligne [LesLignesDuFichier $FichierCsv] {
	regsub -all {\"} $Ligne "" Ligne
	if {$PremiereFois} {
	    regsub -all " " $Ligne "_" Ligne
	    set LesHeaders [split $Ligne "\t"]
	    set PremiereFois 0
	    continue
	}
	set LesMots [split $Ligne "\t"]
	set Gs [lindex $LesMots 2]
	regsub -all {[ \?]} $Gs "" Gns
	set LesGn [split $Gns "/"]
	foreach H $LesHeaders V $LesMots {
	    foreach Gn $LesGn {
		lappend CPG(ListOf,Gn) $Gn
		lappend CPG($Gn,$H) $V
	    }
	}
    }
    set CPG(ListOf,Gn) [lsort -unique $CPG(ListOf,Gn)]
    return [CilioPathyGenes $Qui $Quoi]
}

proc AamForCilioPathyGenes {} {
    foreach Gn [CilioPathyGenes ListOf Gn] {
	set Trouve 0
	set Acs [QuestionDeScience GeneQuid "ret GnAc $Gn"]
	foreach Ac [split $Acs " "] {
	    set OX [QuestionDeScience GeneQuid "ret UniprotData $Ac OX"]
	    if { ! [regexp {NCBI_TaxID=9606( |;)} $OX]} { continue }
	    #set GnLu [QuestionDeScience GeneQuid "ret AcGn $Ac"]
	    set GnLu ""
	    set N [NIAG $Ac N]
	    if {$N==""} { continue }
	    set Trouve 1
	    #Espionne "$Gn $Ac $GnLu $N"
	    lappend LesNoms $N
	}
	if { ! $Trouve } { Espionne "Je ne trouve rien pour $Gn" }
    }
    Espionne $LesNoms
#    Espionne [AllAboutMacsimPourTous "[RepertoireDuGenome]/AAM_CilioPathyGenes_OK.tsv" [join $LesNoms ","]]
    Espionne [AllAboutMacsimPourTous "[RepertoireDuGenome]/AAM_CilioPathyGenes_1759.tsv" [join $LesNoms ","]]
    return $LesNoms
}



proc CilioCartaProject {{Qui ""} {Quoi ""}} {
    global PCC
    if {[info exists PCC($Qui,$Quoi)]} { return $PCC($Qui,$Quoi) }
    if {[info exists PCC("EstCharge")]} { return "" }
    set PCC("EstCharge") 1

    set LesDeOi [glob -nocomplain "/gstock/*/DeOi"]
    set LesProj {}
    foreach DeOi $LesDeOi {
	set Proj [file tail [file dirname $DeOi]]
	lappend LesProj $Proj
    }
    
    set LesTypes [list prottfa blastp taxobla descritptifs msf]

    set LesProj [lsort $LesProj]
    set PCC(ListOf,Project) $LesProj
    foreach Pro $LesProj {
	set Message [format "%-15s" $Pro]
	foreach Type $LesTypes {
	    set Rep "/gstock/$Pro/$Type"
	    if {[FileAbsent $Rep]} {
		set PCC($Pro,$Type) 0
	    } else {
		cd "/gstock/$Pro/$Type"
		set PCC($Pro,$Type) [exec ls -f | wc -l]
	    }
	    append Message [format "%10d %s" $PCC($Pro,$Type) $Type]
	}
	Espionne $Message
    }
    return [CilioCartaProject $Qui $Quoi]
}

proc InventOi {{Qui ""} {Quoi ""} {Defaut ""} } {
    LogWscope [Environ]
    set RG $Qui
    if { ! [file exists "$RG/beton"]} { return $Defaut }
    scan [PremiereLigneDuFichier "$RG/fiches/bornesdespabs"] "%s" Premier
    if {[file exists "$RG/blastp/$Premier"] && [file exists "$RG/taxobla/$Premier"]}  { return "lightgreen" }
    if {[file exists "$RG/taxobla/$Premier"]} { return "yellow" }
    return "orange"
}

proc OiName {{Qui ""} {Quoi ""}} {
    global OiName

    if {[info exists OiName($Qui,$Quoi)]} { return $OiName($Qui,$Quoi) }
    if {[info exists OiName("EstCharge")]} {
	if {[info exists OiName($Qui,OX)]} {
	    set OX $OiName($Qui,OX)
	    if {[info exists OiName($OX,$Quoi)]} { return $OiName($OX,$Quoi) }
	}
	return ""
    }
    set OiName("EstCharge") 1

    set ProteomeDir "/genomics/link/CilioCarta/banques"
    set OiName(ProteomeDir,) $ProteomeDir

    set Alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    NousAllonsAuBoulot $ProteomeDir
    foreach Orga [lsort [glob *]] {
	if {[regexp {\.p|\.log} $Orga]} { continue }
	if { ! [regexp {([A-Z][a-z]+)_([a-z]+)_([0-9]+)} $Orga Match G E OX]} { continue }
	set Ge [string range $G 0 1]
	set Es [string totitle [string range $E 0 1]]
	set GeEs "$Ge$Es"
	set Info "$GeEs [format %8d $OX] $Orga"
	set InfoDe($OX) $Info
	set OrgaDe($OX) $Orga
	lappend LesGeEs $GeEs
	lappend LesOX   $OX
	lappend LesOrga $Orga
	incr NbCops($GeEs)
    }
    set iAlpha -1
    foreach GeEs $LesGeEs OX $LesOX {
	set Prefixe $GeEs
	if {$NbCops($GeEs)==1} {
	    set iAlpha -1
	} else {
	    incr iAlpha
	    append Prefixe [string index $Alphabet $iAlpha]
	}
	set Orga $OrgaDe($OX)
	set OiName($OX,Prefixe) $Prefixe
	set OiName($OX,Orga)    $OrgaDe($OX) 
	set OiName($OX,Info)    $InfoDe($OX) 
	set OiName($OX,Fasta)   "$ProteomeDir/$OrgaDe($OX)" 
	set OiName($Prefixe,OX) $OX
	set OiName($Orga,OX)    $OX
	lappend LesPrefixe $Prefixe
    }
    set LesOXTries [lsort -integer $LesOX]
    set LesPrefixe [lsort $LesPrefixe]
    set LesInfo {}
    foreach Prefixe $LesPrefixe {
	set OX $OiName($Prefixe,OX)
	lappend LesInfo "[format %-5s $Prefixe] $InfoDe($OX)" 
    }
    set OiName(ListOf,Prefixe) [lsort $LesPrefixe]
    set OiName(ListOf,OX)      $LesOXTries
    set OiName(ListOf,Orga)    $LesOrga
    set OiName(ListOf,Info)    $LesInfo

    OnRevientDuBoulot
    return [OiName $Qui $Quoi]
}

proc CreeBlastDatabasesWithOrthoinspectorProteomes {} {
    NousAllonsAuBoulot "[RepertoireDuGenome]/newbanques"
    set LesCrees {}
    foreach P [lsort [glob *]] {
	if {[regexp {\.p} $P]} { continue }
	Espionne $P
	exec formatdb -i $P -p T -o
	file rename formatdb.log $P.formatdb.log
	lappend LesCrees $P 
    }
    OnRevientDuBoulot
    return $LesCrees
}

proc RajouteEnFinDeEnteteFasta {{FichierFastaIn ""} {Fin ""} {FichierFastaOut ""} {Clean ""}} {
    set MaxLigne 900

    set Clean [string equal -nocase $Clean "Clean"]
    #rR attention il faut le blanc en début de ce qu'on rajoute
    set LeNouveau {}
    foreach Ligne [LesLignesDuFichier $FichierFastaIn] {
	if {[regexp "^>" $Ligne] && ! [regexp $Fin $Ligne] } {
	    set F [string length $Fin]
	    set L [string length $Ligne]
	    if {$F +$L > 960 } {
		set Milieu [expr $L/2]
		set Excuse " ... HERE XXXX CHARACTERS WERE CUTTED ... "
		set ACouper [expr $L - $MaxLigne + [string length $Excuse]]
		regsub "XXXX" $Excuse $ACouper Excuse
		set Half [expr $ACouper/2]
		set AvantMilieu [expr $Milieu - $Half]
		set ApresMilieu [expr $Milieu + $Half]
		set LigneCoupee ""
		append LigneCoupee [string range $Ligne 0 $AvantMilieu]
		append LigneCoupee $Excuse
		append LigneCoupee [string range $Ligne $ApresMilieu end]
		set Ligne $LigneCoupee
	    }
	    append Ligne $Fin
	}
	if {$Clean} { regsub -all {[\[\]]} $Ligne "" Ligne }
	lappend LeNouveau $Ligne

    }
    SauveLesLignes $LeNouveau dans $FichierFastaOut
    return $FichierFastaOut
}

proc RajouteOXDansEnteteFasta {{FichierFastaIn ""} {OX ""} {FichierFastaOut ""}} {
    set LeNouveau {}
    foreach Ligne [LesLignesDuFichier $FichierFastaIn] {
	if {[regexp "^>" $Ligne] && ! [regexp { OX=([0-9]+)} $Ligne] } { append Ligne " OX=$OX" }
	lappend LeNouveau $Ligne

    }
    SauveLesLignes $LeNouveau dans $FichierFastaOut
    return $FichierFastaOut
}

proc RajouteOXDansBanqueOrthoinspector {{Qui ""}} {
    #rR Quand j'ai créé les protéomes et les banques blast de Orthoinspector j'ai mis TAXID=9606 et non pas OX=9606
    #rR Je corrige ça ici

    if {$Qui==""} { set Qui "*" }

    set RepBank "[RepertoireDuGenome]/banques"
    NousAllonsAuBoulot $RepBank
    file mkdir "../newbanques"
    set LesNouvellesBanques {}
    foreach Fichier [lsort [glob $Qui]] {
	if {[regexp {\.p} $Fichier]} { continue }
	Espionne $Fichier
	set Nouveau "../newbanques/$Fichier"
	set LeNouveau {}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if { ! [regexp "^>" $Ligne] } { lappend LeNouveau $Ligne; continue }
	    if { ! [regexp { TAXID=([0-9]+)} $Ligne Match OX] } { lappend LeNouveau $Ligne; continue }
	    append Ligne " OX=$OX"
	    lappend LeNouveau $Ligne
	}
	SauveLesLignes $LeNouveau dans $Nouveau
	lappend LesNouvellesBanques $Fichier
    }
    OnRevientDuBoulot
    return $LesNouvellesBanques
}

proc MajYaProteomes {{TaxId ""}} {
    set LesIDs [QuestionDeScience EVImm "ret FromYannis $TaxId IDs"]
    set LesACs [QuestionDeScience EVImm "ret FromYannis $TaxId IDs"]
    foreach ID $LesIDs AC $LesACs {
	if { ! [regexp "_" $ID]} { continue }   ;#rR on verra plus tard !!!!!!!!!!!!!!!!!!
	set AJour 1
	set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"]
	if {$LesLignesEMBL=={}} {
	    set IdAcRef [UniprotHistory $AC]
	    if {$IdAcRef=="" || IdAcRef=="$ID $AC"} { lappend LesIntrouvablesUniques "$ID $AC"; continue }
	    scan $IdAcRef "%s %s" IdRef AcRef
	    set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"]
	    if {$LesLignesEMBL=={}} { lappend LesIntrouvablesHistoriques "$ID $AC $IdAcRef"; continue } 
	    set AJour 0
	}
	if {$AJour} { continue }
	Espionne "$ID $AC $IdAcRef"
    }	
} 

proc InformeIdYaAndAcYaPourTous {} {
    #rR ne sert pas pour le moment car c'est les mêmes que Oi

    set TestIt [OuiOuNon "Do I do a test only" 0]    

    set leLog {}
    foreach Nom [ListeDesPABs] {
	set Id [ExtraitInfo $Nom "Id:"]
	set Ac [ExtraitInfo $Nom "Ac:"]

	set TFA [QuestionDeScience EVImm "ret FromYannis $Id tfa"]
	set DejaVu($Id) 1
	set IdYa ""
	if {$TFA!=""} {
	    set IdYa $Id
	} else {
	    foreach I [UniprotHistory $Ac "IdHis"] {
		if {[info exists DejaVu($I)]} { continue }
		set DejaVu($I) 1
		set TFA [QuestionDeScience EVImm "ret FromYannis $I tfa"]
		if {$TFA!=""} { set IdYa $I ; break }
	    }
	}
	unset DejaVu

	set TFA [QuestionDeScience EVImm "ret FromYannis $Ac tfa"]
	set DejaVu($Ac) 1
	set AcYa ""
	if {$TFA!=""} {
	    set AcYa $Ac
	} else {
	    foreach A [UniprotHistory $Ac "AcHis"] {
		if {[info exists DejaVu($A)]} { continue }
		set DejaVu($A) 1
		set TFA [QuestionDeScience EVImm "ret FromYannis $A tfa"]
		if {$TFA!=""} { set AcYa $A ; break }
	    }
	}
	unset DejaVu

	set Warning ""
	if {$Id!=$IdYa || $Ac!=$AcYa} { set Warning "********" }
	lappend LeLog "$Nom\t$Ac\t$AcYa\t$Id\t$IdYa\t$Warning"
	if {$IdYa!="" && ! $TestIt} { InformeSansDemander $Nom "IdYa: $IdYA" }
	if {$AcYa!="" && ! $TestIt} { InformeSansDemander $Nom "AcYa: $AcYa" }
    }
    return $LeLog
} 

proc InformeIdYaRefAndAcYaRefPourTous {} {
    #rR ne sert pas pour le moment car c'est les mêmes que Oi

    set TestIt [OuiOuNon "Do I do a test only" 0]    

    set leLog {}
    foreach Nom [ListeDesPABs] {
	set Id [ExtraitInfo $Nom "Id:"]
	set Ac [ExtraitInfo $Nom "Ac:"]
	set IdAcRef [UniprotHistory $Ac "IdAcRef"]
	set IdYaRef ""
	set AcYaRef ""
	scan $IdAcRef "%s %s" IdYaRef AcYaRef
	set Warning ""
	if {$Id!=$IdYaRef || $Ac!=$AcYaRef} { set Warning "********" }
	lappend LeLog "$Nom\t$Ac\t$AcYaRef\t$Id\t$IdYaRef\t$Warning"
	if {$IdYaRef!="" && ! $TestIt} { InformeSansDemander $Nom "IdYaRef: $IdYaRef" }
	if {$AcYaRef!="" && ! $TestIt} { InformeSansDemander $Nom "AcYaRef: $AcYaRef" }
    }
    return $LeLog
} 

proc MajOiProteomes {{TaxId ""}} {
    set LesIDs [QuestionDeScience EVImm "ret FromOrthoInspector $TaxId IDs"]
    set LesACs [QuestionDeScience EVImm "ret FromOrthoInspector $TaxId IDs"]
    foreach ID $LesIDs AC $LesACs {
	if { ! [regexp "_" $ID]} { continue }   ;#rR on verra plus tard !!!!!!!!!!!!!!!!!!
	set AJour 1
	set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"]
	if {$LesLignesEMBL=={}} {
	    set IdAcRef [UniprotHistory $AC]
	    if {$IdAcRef=="" || IdAcRef=="$ID $AC"} { lappend LesIntrouvablesUniques "$ID $AC"; continue }
	    scan $IdAcRef "%s %s" IdRef AcRef
	    set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"]
	    if {$LesLignesEMBL=={}} { lappend LesIntrouvablesHistoriques "$ID $AC $IdAcRef"; continue } 
	    set AJour 0
	}
	if {$AJour} { continue }
	Espionne "$ID $AC $IdAcRef"
    }	
} 

proc InformeIdOiAndAcOiPourTous {} {

    set DoIt [OuiOuNon "Do I write to info files"]    

    set leLog {}
    foreach Nom [ListeDesPABs] {
	set Id [ExtraitInfo $Nom "Id:"]
	set Ac [ExtraitInfo $Nom "Ac:"]

	set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $Id tfa"]
	set DejaVu($Id) 1
	set IdOi ""
	if {$TFA!=""} {
	    set IdOi $Id
	} else {
	    foreach I [UniprotHistory $Ac "IdHis"] {
		if {[info exists DejaVu($I)]} { continue }
		set DejaVu($I) 1
		set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $I tfa"]
		if {$TFA!=""} { set IdOi $I ; break }
	    }
	}
	unset DejaVu

	set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $Ac tfa"]
	set DejaVu($Ac) 1
	set AcOi ""
	if {$TFA!=""} {
	    set AcOi $Ac
	} else {
	    foreach A [UniprotHistory $Ac "AcHis"] {
		if {[info exists DejaVu($A)]} { continue }
		set DejaVu($A) 1
		set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $A tfa"]
		if {$TFA!=""} { set AcOi $A ; break }
	    }
	}
	unset DejaVu

	set Warning ""
	if {$Id!=$IdOi || $Ac!=$AcOi} { set Warning "********" }
	lappend LeLog "$Nom\t$Ac\t$AcOi\t$Id\t$IdOi\t$Warning"
	if {$IdOi!="" && $DoIt} { InformeSansDemander $Nom "IdOi: $IdOi" }
	if {$AcOi!="" && $DoIt} { InformeSansDemander $Nom "AcOi: $AcOi" }
    }
    return $LeLog
} 

proc InformeIdRefAndAcRefPourTous {} {

    set TestIt [OuiOuNon "Do I do a test only" 0]    

    set leLog {}
    foreach Nom [ListeDesPABs] {
	set Id [ExtraitInfo $Nom "Id:"]
	set Ac [ExtraitInfo $Nom "Ac:"]
	set IdAcRef [UniprotHistory $Ac "IdAcRef"]
	set IdRef ""
	set AcRef ""
	scan $IdAcRef "%s %s" IdRef AcRef
	set Warning ""
	if {$Id!=$IdRef || $Ac!=$AcRef} { set Warning "********" }
	lappend LeLog "$Nom\t$Ac\t$AcRef\t$Id\t$IdRef\t$Warning"
	if {$IdRef!="" && ! $TestIt} { InformeSansDemander $Nom "IdRef: $IdRef" }
	if {$AcRef!="" && ! $TestIt} { InformeSansDemander $Nom "AcRef: $AcRef" }
    }
    return $LeLog
} 

proc UniprotHistory {{Qui ""} {Quoi ""}} {
    #rR on rend la référence ou l'historique de Id ou Ac
    #rR uniprot ne rend que le premier si on lui fournit l'id, mais il rend l'historique avec ac

    if {$Quoi==""} { set Quoi "History" }

    set Access [string toupper $Qui]
    set Url "http://www.uniprot.org/uniprot/$Access.txt?version=*"
 
    set LesTFAs [LesLignesDuFichier $Url]
    set IdReference ""
    set IdHistory {}
    set AcReference ""
    set AcHistory {}
    set IdAcReference ""

    set HistoryOfId {}
    set HistoryOfAc {}
    
    foreach Ligne $LesTFAs {
	if {[regexp {ID   ([^ ]+)} $Ligne Match IDLu]} {
	    if {$IDLu!=""} {
		if {$IdReference==""} { set IdReference $IDLu }
		lappend IdHistory $IDLu
		lappend HistoryOfId $IDLu
	    }
	}
	if {[regexp {AC   (.+)} $Ligne Match ACsLus]} {
	    set ACs $ACsLus
	    regsub -all {[ ;]+} $ACs " " ACs
	    set LesACs [split [string trim $ACs] " "]
	    if {$LesACs!={}} {
		lappend HistoryOfAc $ACsLus
		if {$AcReference==""} {
		    set AcReference [lindex $LesACs 0]
		    if {$AcReference!=$Qui} { return [UniprotHistory $AcReference $Quoi] }
		}
		foreach AC $LesACs {
		    lappend AcHistory $AC
		}
	    }
	}
    }
    set IdHistory [ListeSansDoublon $IdHistory]
    set AcHistory [ListeSansDoublon $AcHistory]

    set IdAcReference "$IdReference $AcReference"

    if {[regexp -nocase "^IdAcR" $Quoi]} { set Quoi "IdAcReference" }
    if {[regexp -nocase "^IdR"   $Quoi]} { set Quoi "IdReference" }
    if {[regexp -nocase "^IdH"   $Quoi]} { set Quoi "IdHistory" }
    if {[regexp -nocase "^AcR"   $Quoi]} { set Quoi "AcReference" }
    if {[regexp -nocase "^AcH"   $Quoi]} { set Quoi "AcHistory" }    

    if {[info exists $Quoi]} { return [set $Quoi] }
    
    if {[regexp -nocase "^H" $Quoi]} {
	set LeHis {}
	foreach A $HistoryOfAc I $HistoryOfId {
	    lappend LeHis "$I\t$A"
	}
	set LeHis [ListeSansDoublon $LeHis]
	return $LeHis
    }
    return ""
}

proc PABsDuIdOuAc {IdOuAc {Science ""}} {
    global PABsDuIdOuAc

    if { $Science!="" && ! [OnTraite $Science] } {
    	return [QuestionDeScience Science "ret PABsDuIdOuAc $IdOuAc"]
    }

    set IDOUAC [string toupper $IdOuAc]

    if {[info exists PABsDuIdOuAc($IDOUAC)]} { return $PABsDuIdOuAc($IDOUAC) }
    if {[info exists PABsDuIdOuAc("EstCharge")]} { return "" }
    set PABsDuIdOuAc("EstCharge") 1

    foreach Nom [ListeDesPABs] {
	set Id [ExtraitInfo $Nom "Id:"]
	if {$Id!=""} { set ID [string toupper $Id] ; lappend PABsDuIdOuAc($ID) $Nom }
	set Ac [ExtraitInfo $Nom "Ac:"]
	if {$Ac!=""} { set AC [string toupper $Ac] ; lappend PABsDuIdOuAc($AC) $Nom }
    }
    return [PABsDuIdOuAc $IdOuAc]
}

proc OiOrthologsFromCilioCarta {Query {Action ""} {OrganismList ""}} {
    global OiOrthologsFrom
    #rR Action can be IDs, ACs, Contains_P12345

    if {$Action==""} { set Action "IDs" }

    if {$Query==""} { return "" }

    if {[regexp {^CIL[0-9]+$} $Query]} {
	set Nom $Query
    } else {
	set Nom [PABsDuIdOuAc $Query "CilioCarta"]
    }
    if {$Nom==""} { return "" }

    set Action [string toupper $Action]

    if {[info exists OiOrthologsFrom($Nom,$Action)]} { return $OiOrthologsFrom($Nom,$Action) }
    if {[info exists OiOrthologsFrom($Nom,ESTCHARGE)]} {
	if {[regexp {CONTAINS_(.+)} $Action Match Access]} {
	    if {[info exists OiOrthologsFrom($Access,REFERENCE)]} {
		return [expr [lsearch $Nom $OiOrthologsFrom($Access,REFERENCE)] >= 0]
	    }
	    return 0
	}
	return ""
    }
    set OiOrthologsFrom($Nom,ESTCHARGE) 1
    

    #rR on peut prendre Oi au lieu de Ya car c'est les mêmes
    if {[OnTraite "CilioCarta"]} {
	set IdQuery [ExtraitInfo $Nom "IdOi:"]
	set AcQuery [ExtraitInfo $Nom "AcOi:"]
    } else {
	set IdQuery [QuestionDeScience "CilioCarta" "ret ExtraitInfo $Nom IdOi:"]
	set AcQuery [QuestionDeScience "CilioCarta" "ret ExtraitInfo $Nom AcOi:"]
    }
    set LesHeader [OiLesTFAsDesOrthologs $IdQuery $OrganismList "GetHeader"]
    foreach H $LesHeader {
	regsub ">" $H "" H
	scan $H "%s %s" A B
	if {[regexp {\|} $A]} {
	    lassign [split $A "|"] Banque Ac Id
	} else {
	    set Id $A
	    set Ac $B
	}

	#rR 2014/07/08 pour éventuellement prendre la ref plus récente dans Yannis
	if {[OnTraite "EVImm"]} {
	    set TFA [FromYannis $Ac "tfa"]
	} else {
	    set TFA [QuestionDeScience "EVImm" "ret FromYannis $Ac tfa"]
	}
	if {$TFA==""} {
	    set IdAcNow [UniprotHistory $Id "IdAcRef"]
	    if {$IdAcNow==""} { continue }
	    lassign [split $IdAcNow "\t"] Id Ac
	} 

	set ID [string toupper $Id]
	set AC [string toupper $Ac]
	if {$Id!=""} { lappend OiOrthologsFrom($Nom,IDS) $Id }
	if {$Ac!=""} { lappend OiOrthologsFrom($Nom,ACS) $Ac }
	lappend OiOrthologsFrom($ID,REFERENCE) $Nom
	lappend OiOrthologsFrom($AC,REFERENCE) $Nom
    }
    return [OiOrthologsFromCilioCarta $Query $Action $OrganismList]
}

proc CompareOrganismsOiYannis {} {
    foreach TOI [OiOrganism ListOf TaxId] {
	set TYA [YannisOrganism $TOI TaxId]
#	Espionne "$TOI $TYA"
    }
    Espionne ""
    foreach TYA [YannisOrganism ListOf TaxId] {
	set TOI [OrganismFromOrthoInspector $TYA TaxId]
	set FOS [YannisOrganism $TYA FullOs]
	set OS  [YannisOrganism $TYA OS]
	if {$TOI==""} {
	    set TOI [OrganismFromOrthoInspector $OS TaxId]
	    set FOSoi [OrganismFromOrthoInspector $TOI FullOs]
	    Espionne "$TYA $TOI $FOS $FOSoi"
	}
    }
}

proc YannisOrganism {{Qui ""} {Quoi ""}} {
    global YannisOrganism

    if {$Qui==""} { set Qui "ListOf" ; set Quoi "Keys" }

    set LesKeys [list TaxId FullOs Filename OS Strain Keys]
    foreach K $LesKeys {
	if {[string equal -nocase $Quoi $K]} { set Quoi $K ; break }
    }

    if {[info exists YannisOrganism($Qui,$Quoi)]}  { return $YannisOrganism($Qui,$Quoi) }
    if {[info exists YannisOrganism("EstCharge")]} {
	if {[info exists YannisOrganism($Qui,Id)]} {
	    set Id $YannisOrganism($Qui,Id)
	    if {[info exists YannisOrganism($Id,$Quoi)]} { return $YannisOrganism($Id,$Quoi) }
	}
	return ""
    }
    set YannisOrganism("EstCharge") 1

    set Rep "/home/nevers/StageJuin/Proteomes"
    set YannisOrganism(Rep,) $Rep 

    NousAllonsAuBoulot $Rep
    
    set LesFichiersTfa [lsort [glob -nocomplain "*.tfa"]]
			 
    foreach Fichier $LesFichiersTfa {
	if { ! [regexp {([0-9]+)_([A-Z][a-z]+)_([a-z\.\-]+)_(.*)} $Fichier Match TaxId G E R]} { FaireLire "Bas $Fichier"; continue }
	set Filename "$Rep/$Fichier"
	set OS "${G}_$E"
	set Strain $R
	regsub "\.tfa$" $Strain "" Strain
	if {$Strain=="-"} { set Strain "" }
	set FullOs "$TaxId $G $E $Strain"

	lappend YannisOrganism(ListOf,TaxId)      $TaxId
	lappend YannisOrganism(ListOf,OS)         $OS
	lappend YannisOrganism(ListOf,Strain)     $Strain
	lappend YannisOrganism(ListOf,Filename)   $Fichier
	lappend YannisOrganism(ListOf,FullOs)     $FullOs

	set YannisOrganism($TaxId,TaxId)    $TaxId
	set YannisOrganism($TaxId,OS)       $OS
	set YannisOrganism($TaxId,FullOs)   $FullOs
	set YannisOrganism($TaxId,Strain)   $Strain
	set YannisOrganism($TaxId,Filename) $Filename

	lappend YannisOrganism($OS,TaxId)   $TaxId
	set YannisOrganism($FullOs,TaxId)   $TaxId
	set YannisOrganism($Filename,TaxId) $TaxId
    }
    set YannisOrganism(ListOf,Keys) $LesKeys
    set YannisOrganism(ListOf,TaxId)      [lsort -integer $YannisOrganism(ListOf,TaxId)]
    set YannisOrganism(ListOf,OS)         [lsort -unique  $YannisOrganism(ListOf,OS)]
    set YannisOrganism(ListOf,FullOs)     [lsort          $YannisOrganism(ListOf,FullOs)]

    OnRevientDuBoulot

    return [YannisOrganism $Qui $Quoi]
		   
}

proc OiOrganism {{Qui ""} {Quoi ""}} {
    global OiOrganism

    #rR on utilise oi_client -organism_ids pour avoir les correspondances Id de Orthoinspector et TaxId
    #rR au premier appel on charge TaxId dasn EVImm ça peut être long

    if {$Qui==""} { set Qui "ListOf" ; set Quoi "Keys" }

    set LesKeys [list Id Identifier TextOs OS TaxId Keys]
    foreach K $LesKeys {
	if {[string equal -nocase $Quoi $K]} { set Quoi $K ; break }
    }

    if {[info exists OiOrganism($Qui,$Quoi)]}  { return $OiOrganism($Qui,$Quoi) }
    if {[info exists OiOrganism("EstCharge")]} {
	if {[info exists OiOrganism($Qui,Id)]} {
	    set Id $OiOrganism($Qui,Id)
	    if {[info exists OiOrganism($Id,$Quoi)]} { return $OiOrganism($Id,$Quoi) }
	}
	return ""
    }
    set OiOrganism("EstCharge") 1
    
    #rR il faut mettre le catch sinon ca marche pas
    catch {set Texte [exec oi_client -organism_ids]} Texte
    foreach Ligne [split $Texte "\n"] {
	if { ! [regexp -nocase {id=([0-9]+)[ \t]+identifier=([A-Z0-9]+)[ \t]+(.*)} $Ligne Match Id Identifier TextOs]} { continue }
	scan $TextOs "%s %s" G E
	set OS "${G}_$E"
	set TaxId [Tax $OS]
	if {$TaxId==""} {
	    if {$OS=="Micromonas_sp."}  { set TaxId 296587 }
	    if {$OS=="Salpingoeca_sp."} { set TaxId 946362 }
	}
	if {$TaxId==""} { set TaxId 999999 }
	lappend OiOrganism(ListOf,Id)         $Id
	lappend OiOrganism(ListOf,Identifier) $Identifier
	lappend OiOrganism(ListOf,TextOs)     $TextOs
	lappend OiOrganism(ListOf,OS)         $OS
	lappend OiOrganism(ListOf,TaxId)      $TaxId
	set OiOrganism($Id,Id)         $Id
	set OiOrganism($Identifier,Id) $Id
	set OiOrganism($TextOs,Id)     $Id
	set OiOrganism($OS,Id)         $Id
	set OiOrganism($TaxId,Id)      $Id
	set OiOrganism($TaxId,TaxId)   $TaxId

	set OiOrganism($Id,Identifier) $Identifier
	set OiOrganism($Id,TextOs)     $TextOs
	set OiOrganism($Id,OS)         $OS
	set OiOrganism($Id,TaxId)      $TaxId
    }
    set OiOrganism(ListOf,Keys) $LesKeys
    set OiOrganism(ListOf,Id)         [lsort -integer $OiOrganism(ListOf,Id)]
    set OiOrganism(ListOf,TaxId)      [lsort -integer $OiOrganism(ListOf,TaxId)]
    set OiOrganism(ListOf,Identifier) [lsort          $OiOrganism(ListOf,Identifier)]
    set OiOrganism(ListOf,OS)         [lsort          $OiOrganism(ListOf,OS)]
    set OiOrganism(ListOf,TextOs)     [lsort          $OiOrganism(ListOf,TextOs)]

    return [OiOrganism $Qui $Quoi]
		   
}

proc OiLesTFAsDesOrthologs {{Query ""} {OrgaList ""} {Quoi ""}} {
    if {$OrgaList=="" || [regexp -nocase "Defau" $OrgaList]} { set OrgaList [OiOrgaList]}
    set FicOut "[TmpFile].oi"
    exec /biolo/orthoinspector/oi_client -mode single -query $Query -organism_list $OrgaList -outfmt 5 -out $FicOut
    if {[FileAbsent $FicOut]} { return {} }
    set LesLignes [LesLignesDuFichier $FicOut]
    file delete $FicOut
    if {$Quoi=="GetHeader" || $Quoi=="GetAccess"} {
	set LeRetour {}
	foreach Ligne $LesLignes {
	    if { ! [regexp ">" $Ligne]} { continue }
	    if {$Quoi=="GetHeader"} { lappend LeRetour $Ligne ; continue }
	    scan [string range $Ligne 1 end] "%s" Access
	    if {$Quoi=="GetAccess"} { lappend LeRetour $Access ; continue }
	}
	return $LeRetour
    }
    return $LesLignes
} 

proc OrganismListForCilioCode {{GetWhat ""}} {

    if {$GetWhat==""} { set GetWhat "TaxId" }

    set Fichier [Fiches "ListOfTaxIdCilioCode.txt"]

    set LesTaxId {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }
	lappend LesTaxId $Ligne
    }

    set AsText    [regexp -nocase "AsText" $GetWhat]
    set WithComma [regexp -nocase "AsTextWithComma" $GetWhat]
    set WithSpace [regexp -nocase "AsTextWithSpase" $GetWhat]
    regsub -nocase "AsText.*" $GetWhat "" GetWhat

    set Liste {}
    if {[regexp -nocase "^TaxId" $GetWhat]} {
	set Liste $LesTaxId
    } else {
	foreach TaxId $LesTaxId {
	    set Info [OiOrganism $TaxId $GetWhat]
	    if {$Info==""} { continue }
	    lappend Liste $Info
	}
    }
    if { ! $AsText } { return $Liste }
    set Sep ","
    if {$WithComma} { set Sep "," }
    if {$WithSpace} { set Sep " " }
    return [join $Liste $Sep]
}

proc OiOrgaList {{GetWhat ""}} {

    if {$GetWhat==""} { set GetWhat "GetIdAsTextWithComma" }

#    set OrgaList "82 210 254 140 66 101 72 69 184 9 152 197 49 170 194 37 118 88 169 59 225 119 124 141 138 32 200 255 151 50 18 20 163 186 249 189 99 223 77 221 114 155 188"
    set OrgaList "101,104,109,114,115,116,117,118,119,122,124,125,128,13,138,14,140,141,142,143,146,149,15,151,152,155,159,161,163,169,170,173,174,18,183,184,186,188,189,190,194,197,2,20,200,203,210,212,214,217,22,221,222,223,225,226,232,239,240,242,244,245,246,247,248,249,254,255,257,259,26,29,3,32,33,37,39,4,41,49,50,51,53,59,6,60,65,66,67,69,7,72,77,78,82,88,9,90,92,99"


    set OrgaList [split $OrgaList ", "]
    set OrgaList [lsort -integer $OrgaList]
    
    if {$GetWhat=="GetIdAsTextWithComma"} { return [join $OrgaList ","] }
    if {$GetWhat=="GetIdAsTextWithBlank"} { return [join $OrgaList " "] }

    set Keys [OiOrganism ListOf Keys]
    foreach K $Keys {
	if {[regexp -nocase "Get${K}As" $GetWhat]} {
	    set Li {}
	    foreach O $OrgaList {
		set V [OiOrganism $O $K]
		lappend Li "$O=$V"
	    }
	    if {[regexp "AsTextWithComma" $GetWhat]} { return [join $Li ","] }
	    if {[regexp "AsTextWithBlank" $GetWhat]} { return [join $Li " "] }
	    return $Li
	}
    }
    return $OrgaList
}

proc CorrigeLesDescriptifsEnSupprimantRootEtCellularOrganism {} {
    set LesNouveaux {}
    foreach Nom [ListeDesPABs] {
	set  FichierDescriptif [GscopeFile $Nom descriptifs]
	if {[FileAbsent $FichierDescriptif]} { continue }
	set LeNew {}
	set YaDuNeuf 0
	foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
	    set New $Ligne
	    if { [regexp {OC\:root; cellular organisms; } $New]} {
		incr YaDuNeuf 1
		regsub {OC\:root; cellular organisms; } $New "OC:" New
	    }
	    if { [regexp {Opisthokonta; } $New]} {
		incr YaDuNeuf 1
		regsub {Opisthokonta; } $New "" New
	    }
	    lappend LeNew $New
	}
	if {$YaDuNeuf} {
	    Espionne "$Nom $YaDuNeuf"
	    SauveLesLignes $LeNew dans $FichierDescriptif
	    lappend LesNouveaux $FichierDescriptif
	}
    }
    return $LesNouveaux
}

proc CorrigeLesDescriptifs {} {
    set LesOS [QuestionDeScience "CilioCarta" "FromOrthoInspector ListOf OS"]
    set LesNouveaux {}
    foreach Nom [ListeDesPABs] {
	set  FichierDescriptif [GscopeFile $Nom descriptifs]
	if {[FileAbsent $FichierDescriptif]} { continue }
	set LeNew {}
	set YaDuNeuf 0
	foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
	    if { ! [regexp {OS\:  GN\:} $Ligne]} { lappend LeNew $Ligne; continue }
	    if { ! [regexp {DE\:([A-Z][a-z]+) ([a-z\.]+) } $Ligne Match G E]} { lappend LeNew $Ligne; continue }
	    set YaDuNeuf 1
	    set New $Ligne
	    regsub {OS\:  GN\:}                    $New "OS:$G $E GN:" New
	    regsub {DE\:([A-Z][a-z]+) ([a-z\.]+) } $New "DE:"           New
	}
	if {$YaDuNeuf} {
	    SauveLesLignes $LeNew dans $FichierDescriptif
	    lappend LesNouveaux $FichierDescriptif
	}
    }
    return $LesNouveaux
}


proc VerifieLeFasta Fichier {
    #rR j'ai ecrit ca pour voir pourquoi le proteome de OrthoInspector etait mauvais ... mais c'était la faute a formatdb
    set n 0
    set t 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	incr t
	if {[regexp {^>([^ ]+)( |$)} $Ligne Match Access]} {
	    if { ! [regexp -nocase {^[A-Z0-9_\-\:\.]+$} $Access]} { FaireLire "Wrong $Access" }
	    set ACCESS [string toupper $Access]
	    if {[info exists DejaVu($ACCESS)]}                  { FaireLire "DejaVu $Access" }
	    set DejaVu($ACCESS) 1
	    if {[string length $Access]>50}                     { FaireLire "long $Access" }
	    if {[string length $Ligne]>1000}                    { FaireLire "long $Ligne" }
	    incr n
	    lappend LeNouveau $Ligne
	    continue
	}
	if {[regexp -nocase {[^A-Z]} $Ligne]}                   { FaireLire "wrong seq for $Access\n$Ligne" } 
	if {$Ligne==""}                                         { continue }
	lappend LeNouveau $Ligne
    }
    SauveLesLignes $LeNouveau dans $Fichier.NEW
    return "$t lines for $n accesses"
}

proc TailleDeLaBanque {Banque} {
    set Taille 0
    foreach F [glob -nocomplain $Banque.*] {
	set Size [file size $F]
	incr Taille $Size
    }
    return "$Taille [expr $Taille/1000 + 1]KO [expr $Taille/1000000 + 1]MO [expr $Taille/1000000000 + 1]GO"
}

proc CilioCartaVersion {} {
    return 1.2
}

proc CilioCartaDir {} {
    return "/genomics/link/CilioCarta/DeKirsley/101"
}

proc CilioDesc {{Qui ""} {Quoi ""}} {
    global CilioDesc

    if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }

    if {[info exists CilioDesc($Qui,$Quoi)]} { return $CilioDesc($Qui,$Quoi) }
    if {[info exists CilioDesc("EstCharge")]} { return "" }
    set CilioDesc("EstCharge") 1

    set FichierCsv "[CilioCartaDir]/101_ciliopathies_desc.csv"
    set CilioDesc(filename,) $FichierCsv

    LoadTxlWithRowsOfCells $FichierCsv CilioDesc 0 "\t"

    set CilioDesc(ListOf,Gene)   $CilioDesc(ListAllPlease,)
    set CilioDesc(ListOf,Header) $CilioDesc(ListHeaderPlease,)
    return [CilioDesc $Qui $Quoi]
}

proc CilioMapping {{Qui ""} {Quoi ""}} {
    global CilioMapping

    if {$Qui==""} { set Qui "ListOf"; set Quoi "Keys" }

    if {[info exists CilioMapping($Qui,$Quoi)]} { return $CilioMapping($Qui,$Quoi) }
    if {[info exists CilioMapping("EstCharge")]} {
	if {[info exists CilioMapping($Qui,GI)] \
		&& [info exists CilioMapping($CilioMapping($Qui,GI),$Quoi)]} {
	    return $CilioMapping($CilioMapping($Qui,GI),$Quoi)
	}
	return ""
    }
    set CilioMapping("EstCharge") 1

    set FichierCsv "[CilioCartaDir]/101_ciliopathies_mapping_ids.tsv"
    set CilioMapping(filename,) $FichierCsv

    LoadTxlWithRowsOfCells $FichierCsv CilioMapping 0 "\t"

    set CilioMapping(ListOf,GI) $CilioMapping(ListAllPlease,)
    set CilioMapping(ListOf,Header)  $CilioMapping(ListHeaderPlease,)

    set LesH [list gene_stable_id gene_display_label transcript_stable_id translation_stable_id UniProt_ID]
    set LesK [list GI             GN                 TI                   PI                    AC        ]
    set CilioMapping(ListOf,Keys) $LesK
    foreach GI $CilioMapping(ListOf,GI) {
	set CilioMapping($GI,All) "$GI"
	foreach H $LesH K $LesK {
	    set $K [string trim $CilioMapping($GI,$H)]
	    append CilioMapping($GI,All) "\t[set $K]"
	    lappend CilioMapping(ListOf,$K) [set $K]
	    set CilioMapping($GI,$K) [set $K]
	    set CilioMapping([set $K],GI) $GI
	}
    }

    return [CilioMapping $Qui $Quoi]
}

proc CilioPep {{Qui ""} {Quoi ""}} {
    global CilioPep

    if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }

    if {[info exists CilioPep($Qui,$Quoi)]} { return $CilioPep($Qui,$Quoi) }
    if {[info exists CilioPep("EstCharge")]} { return "" }
    set CilioPep("EstCharge") 1

    set Fichier "[CilioCartaDir]/101_ciliopathies_pep.fasta"

    set LesK [list AC ID GN     GI   TI   PI   DE     SO          PM     CS             LO       CN           SQ FA]
    set LesG [list AC ID ValiGN ENSG ENST ENSP ValiDE SourceOfDef PubMed CiliomeStudies Location CuratorsNote "" ""]
    set CilioPep(ListOf,Header)       $LesK
    set CilioPep(ListOf,GscopeHeader) $LesG

    set LesLignes [LesLignesDuFichier $Fichier]
    lappend LesLignes ">fin"
    set PremiereFois 1
    foreach Ligne $LesLignes {
	if { ! [regexp ">" $Ligne]} {
	    lappend LaSeq $Ligne
	    continue
	}
	if {$PremiereFois} {
	    set PremiereFois 0
	    set LaSeq {}
	} else {
	    set SQ [join $LaSeq "\n"]
	    set LaSeq {}
	    set FA [SequenceFormatTFA $SQ "$GN $DE ID=$ID AC=$AC PI=$PI"]
	    foreach K $LesK {
		set CilioPep($GI,$K) [set $K]
		lappend CilioPep(ListOf,$K) [set $K]
	    }
	}
	if {$Ligne==">fin"} { break }
        #   AC     ID         DE          OS              GN
	#sp|Q8N157|AHI1_HUMAN Jouberin OS=Homo sapiens GN=AHI1 PE=1 SV=1

	if { ! [regexp {([^ ]+) ([^=]+)} $Ligne Match Access DE]} { FaireLire "ca merde pour $Ligne" }
	set AC [lindex [split $Access "|"] 1]
	set ID [lindex [split $Access "|"] 2]
	
	set DE [string trim [string range $DE 0 end-2]]
	regsub { PE=.*} $Ligne "" Ligne
	set GN [string trim [StringApres "GN=" dans $Ligne]]
	regsub { GN=.*} $Ligne "" Ligne
	set OS [StringSuivant "OS=" dans $Ligne]
#	Espionne "$AC $ID $GN $OS / $DE"

	set GI [CilioMapping $AC GI]
	set TI [CilioMapping $AC TI]
	set PI [CilioMapping $AC PI]

	set gn [CilioMapping $AC GN]         ; if {$gn!=$GN} { FaireLire "dans mapping $AC/$gn/!=/$GN/$AC [CilioMapping $AC All]" }
	set gn [CilioDesc $GI Gene_Name]     ; if {0 && $gn!=$GN} { FaireLire "dans desc $GI/$gn/!=$GN/" }
	set ei [CilioDesc $GI "Ensembl_ID"]  ; if {0 && $ei!=$GI} { FaireLire "Ca merde pour Ensembl_Id=$ei= et GI=$GI=" }

	set de [CilioDesc $GI "Description"] 	
	set SO ""
	if {[regexp {([^\[]+) \[Source:(.*)\]} $de Match NewDE SO]} {
	    set de [string trim $NewDE]
	    set SO [string trim $SO]
	}
	if {0 && $de!=$DE} {
	    regsub "protein " $DE "" DEcoupe
	    if {[string trim $de]!=[string trim $DEcoupe]} { FaireLire "Ca merde pour \n$de\n$DEcoupe" }
	}

	set PM [CilioDesc $GI "PubMed_IDs"]
	set CS [CilioDesc $GI "Ciliome_studies"]
	set LO [CilioDesc $GI "Localisation"]
	set CN [CilioDesc $GI "Curators_Note"]
    }

    foreach K $LesK {
	set CilioPep(ListOf,$K) [lsort -unique $CilioPep(ListOf,$K)]
    }
    foreach GI $CilioPep(ListOf,GI) {
	set GN $CilioPep($GI,GN)
	set PI $CilioPep($GI,PI)
	foreach K $LesK {
	    set CilioPep($GN,$K) $CilioPep($GI,$K)
	    set CilioPep($PI,$K) $CilioPep($GI,$K)
	}
    }
    
    return [CilioPep $Qui $Quoi]
}

proc InformeParProtemblPourTous {{DoIt ""}} {
    if {$DoIt==""} {
	if {[OuiOuNon "Do I really do the updates"]} { set DoIt "DoIt" }
    }
    set DoIt [string equal -nocase $DoIt "DoIt"] 
    foreach Nom [ListeDesPABs] {
	set FicEmbl [GscopeFile $Nom protembl]
	set LesLignesEMBL [LesLignesDuFichier $FicEmbl]
	DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
	set LesK [list ID AC DE GN OS OC OX]
	foreach K $LesK {
	    set V [set $K]
	    if {$V==""} { continue }
	    set ClefInfo $K
	    if {$K=="ID"} {
		if {$ID==$Nom} {
		    #rR pour CilioCarta on va chercher l'ID dans le prottfa
		    set FicTfa [GscopeFile $Nom prottfa]
		    set Header [PremiereLigneDuFichier $FicTfa]
		    scan $Header "%s %s" N I
		    set A "" ; set B ""; set C ""
		    lassign [split $I "|"] A B C
		    if {$C!=""} {
			set ID $C
		    } elseif {$B!=""} {
			set ID $B
		    } else {
			set ID $A
		    }
		}
		set V $ID
		set ClefInfo "Id"
	    }
	    if {$K=="AC"} { set ClefInfo "Ac" }
	    if {$K=="DE"} { set ClefInfo "ValiDE" }
	    if {$K=="GN"} { set ClefInfo "ValiGN" }
	    if {$DoIt} {
		InformeSansDemander $Nom "=$ClefInfo: $V"
	    } else {
		Espionne "InformeSansDemander $Nom =$ClefInfo: $V"
	    }
	    lappend LesInfos "$Nom =$ClefInfo: $V"
	}
    }
    return $LesInfos
}

proc InformeCilioCarta {} {
    FaireLire "Merci de vérifier cette proc, elle est peut-être obsolète"
    foreach Nom [ListeDesPABs] {
	set FicTfa [GscopeFile $Nom prottfa]
	scan [PremiereLigneDuFichier $FicTfa] "%s %s" N Gn
	set GN [CilioPep $Gn GN]
	if {$Gn!=$GN} { FaireLire "Ca merde pour $Nom $Gn!=$GN" }
	#AC ID GN GI TI PI DE SO PM CS LO CN SQ FA"
	foreach K [CilioPep ListOf Header] G [CilioPep ListOf GscopeHeader] {
	    if {$G==""} { continue }
	    set V [CilioPep $GN $K]
	    InformeSansDemander $Nom "$G: $V"
	}	
    }
    return
}

proc CreeProjetGscopeCilioCarta {} {
    set LeTFAs [CilioPep ListOf FA]
    set FichierFasta [SauveLesLignes $LeTFAs dans "[CilioCartaDir]/CilioCarta.fasta"]
    return [Espionne "$FichierFasta est créé.\nMaitenant il faut faire \nsetgscoperr CilioCarta\n et lancer \ngscope\n puis gscope InformeCilioCarta"]
}

######################################## FromOrthoInspector

proc CompareOrganismFromOrthoInspectorAndYannis {} {
    foreach TYA [OrganismFromYannis ListOf TaxId] {
	set OSYA [OrganismFromYannis $TYA OS]
	set FullOsYA [OrganismFromYannis $TYA FullOs]
	set TOI [OrganismFromOrthoInspector $TYA TaxId]
	if {$TOI==""} {
	    set TOI [OrganismFromOrthoInspector $FullOsYA TaxId]
	    if {$TOI==""} {
		set TOI [OrganismFromOrthoInspector $FullOsYA TaxId]
		if {$TOI==""} { FaireLire "Je ne trouve pas\n$TYA $FullOsYA\ndans OrthoInspector" ; continue }
	    }
	}
 	set FullOsOI [OrganismFromOrthoInspector $TYA FullOs]
	if {$FullOsYA==$FullOsOI} { continue }
	Espionne "$FullOsYA\n$FullOsOI"
	Espionne
    }
	    
}

proc OrganismFromOrthoInspector {{Qui ""} {Quoi ""}} {
    #rR on lit le nom du fichier qui contient le taxid et l'os mais avec le strain qui peut-être n'importe quoi.

    global OFOI

    set QUI  [string toupper $Qui]
    regsub " " $QUI "_" QUI
    set QUOI [string toupper $Quoi]
    if {[info exists OFOI($QUI,$QUOI)]}  { return $OFOI($QUI,$QUOI) }
    if {[info exists OFOI("EstCharge")]} {
	if {[info exists OFOI($QUI,TAXID)]} {
	    set LaReponse {}
	    foreach TaxId $OFOI($QUI,TAXID) {
		if {[info exists OFOI($TaxId,$QUOI)]} { lappend LaReponse $OFOI($TaxId,$QUOI) }
	    }
	    return $LaReponse
	}
	return ""
    }
    set OFOI("EstCharge") 1

    set Rep "/biolo/orthoinspector/DataOrthoinspector/Orthoinspector_v2/eukaryota/all"
    set OFOI(REP,) $Rep

    foreach Fichier [lsort [glob -nocomplain "$Rep/*.fasta"]] {
	set Queue [file tail $Fichier]
	#if {[regexp {^[0-9]} $Queue]} { continue }
	set OsDuFichier ""
	set TaxIdDuFichier ""
	regsub {\.fasta$} $Queue "" FullName
	set G ""
	set E ""
	set T ""
	set S ""
	if {[regexp {([a-z]+)_([a-z\-\.]+)_([0-9]+)_(.+)} $FullName Match G E T S]} {
	    set G [string totitle $G]
	    set OsDuFichier "${G}_$E"
	    set FullOs $OsDuFichier
	    set TaxIdDuFichier $T
	    set Strain $S
	    if {$Strain!=""} { append FullOs "_$Strain" }
	}
	if {[regexp {([0-9]+)_([A-Z][a-z]+)_([a-z\-\.]+)(_(.*)|$)} $FullName Match T G E X S]} {
	    set TaxIdDuFichier $T
	    set OsDuFichier "${G}_$E"
	    set FullOs $OsDuFichier
	    set Strain $S
	    if {$Strain!=""} { append FullOs "_$Strain" }
	}
#	if {$TaxIdDuFichier=="9823" && $OsDuFichier=="Cavia_porcellus"} { set TaxIdDuFichier "10141" }
	if {[info exists DejaVu($TaxIdDuFichier)]} { FaireLire "DejaVu $TaxIdDuFichier" }
	set DejaVu($TaxIdDuFichier) 1
	set OsFromTax [Tax $TaxIdDuFichier]
	regsub " " $OsFromTax "_" OsFromTax
	set AfficheOsFromTax "" ; if {$OsFromTax!="$OsDuFichier"} { set AfficheOsFromTax $OsFromTax }

	set TaxId $TaxIdDuFichier
	set Os $OsDuFichier
	regsub "_" $Os " " $Os
	

	set OFOI($TaxId,TAXID)     $TaxId
	set OFOI($TaxId,FULLNAME)  $FullName
	set OFOI($TaxId,FILENAME)  $Fichier
	set OFOI($TaxId,OS)        $Os
	set OFOI($TaxId,FULLOS)    $FullOs
	set OFOI($TaxId,STRAIN)    $Strain
	set OFOI($TaxId,OSFROMTAX) [Tax $TaxId]
	
	set FULLNAME [string toupper $FullName]
	set FULLOS   [string toupper $FullOs]
	set OS       [string toupper $Os]
	set STRAIN   [string toupper $Strain]

	set OFOI($FULLNAME,TAXID)   $TaxId
	set OFOI($FULLOS,TAXID)     $TaxId
	lappend OFOI($OS,TAXID)     $TaxId
	lappend OFOI($STRAIN,TAXID) $TaxId

	lappend OFOI(LISTOF,TAXID)    $TaxId
	lappend OFOI(LISTOF,FULLNAME) $FullName
	lappend OFOI(LISTOF,FULLOS)   $FullOs
#	lappend OFOI(LISTOF,OS)       $Os
	lappend OFOI(LISTOF,STRAIN)   $Strain
	lappend OFOI(LISTOF,FILENAME) $Fichier
    }
    set OFOI(LISTOF,FULLOS)   [lsort -unique $OFOI(LISTOF,FULLOS)]
    set OFOI(LISTOF,FULLNAME) [lsort -unique $OFOI(LISTOF,FULLNAME)]
    set OFOI(LISTOF,FILENAME) [lsort -unique $OFOI(LISTOF,FILENAME)]
    set OFOI(LISTOF,STRAIN)   [lsort -unique $OFOI(LISTOF,STRAIN)]
    foreach FullOS $OFOI(LISTOF,FULLOS) {
	lassign [split $FullOS "_"] G E
	set OS "$G $E"
	lappend OFOI(LISTOF,OS) $OS
    }     
    return [OrganismFromOrthoInspector $Qui $Quoi]
}

proc OrganismFromYannis {{Qui ""} {Quoi ""}} {
    #rR on lit le nom du fichier qui contient le taxid et l'os mais avec le strain qui peut-être n'importe quoi.

    global OFYA

    set QUI  [string toupper $Qui]
    regsub " " $QUI "_" QUI
    set QUOI [string toupper $Quoi]
    if {[info exists OFYA($QUI,$QUOI)]}  { return $OFYA($QUI,$QUOI) }
    if {[info exists OFYA("EstCharge")]} {
	if {[info exists OFYA($QUI,TAXID)]} {
	    set LaReponse {}
	    foreach TaxId $OFYA($QUI,TAXID) {
		if {[info exists OFYA($TaxId,$QUOI)]} { lappend LaReponse $OFYA($TaxId,$QUOI) }
	    }
	    return $LaReponse
	}
	return ""
    }
    set OFYA("EstCharge") 1

#   set Rep "/home/nevers/StageJuin/Proteomes"
    set Rep "/home/nevers/StageJuin/Proteomes"
    set OFYA(REP,) $Rep

    foreach Fichier [lsort [glob -nocomplain "$Rep/*.tfa"]] {
	set Queue [file tail $Fichier]
	#if {[regexp {^[0-9]} $Queue]} { continue }
	set OsDuFichier ""
	set TaxIdDuFichier ""
	regsub {\.tfa$} $Queue "" FullName
	set FullName [string trim $FullName "_-"]
	set G ""
	set E ""
	set T ""
	set S ""
	if {[regexp {([0-9]+)_([A-Z][a-z]+)_([a-z\-\.]+)(_(.*)|$)} $FullName Match T G E X S]} {
	    set TaxIdDuFichier $T
	    set OsDuFichier "${G}_$E"
	    set FullOs $OsDuFichier
	    set Strain $S
	    if {$Strain!=""} { append FullOs "_$Strain" }
	}
	
	if {[info exists DejaVu($TaxIdDuFichier)]} { FaireLire "DejaVu $TaxIdDuFichier" }
	set DejaVu($TaxIdDuFichier) 1
	set OsFromTax [Tax $TaxIdDuFichier]
	regsub " " $OsFromTax "_" OsFromTax
	set AfficheOsFromTax "" ; if {$OsFromTax!="$OsDuFichier"} { set AfficheOsFromTax $OsFromTax }

	set TaxId $TaxIdDuFichier
	set Os $OsDuFichier
	regsub "_" $Os " " $Os
	

	set OFYA($TaxId,TAXID)     $TaxId
	set OFYA($TaxId,FULLNAME)  $FullName
	set OFYA($TaxId,FILENAME)  $Fichier
	set OFYA($TaxId,OS)        $Os
	set OFYA($TaxId,FULLOS)    $FullOs
	set OFYA($TaxId,STRAIN)    $Strain
	set OFYA($TaxId,OSFROMTAX) [Tax $TaxId]
	
	set FULLNAME [string toupper $FullName]
	set FULLOS   [string toupper $FullOs]
	set OS       [string toupper $Os]
	set STRAIN   [string toupper $Strain]

	set OFYA($FULLNAME,TAXID)   $TaxId
	set OFYA($FULLOS,TAXID)     $TaxId
	lappend OFYA($OS,TAXID)     $TaxId
	lappend OFYA($STRAIN,TAXID) $TaxId

	lappend OFYA(LISTOF,TAXID)    $TaxId
	lappend OFYA(LISTOF,FULLNAME) $FullName
	lappend OFYA(LISTOF,FULLOS)   $FullOs
	lappend OFYA(LISTOF,STRAIN)   $Strain
	lappend OFYA(LISTOF,FILENAME) $Fichier
    }
    set OFYA(LISTOF,FULLOS)   [lsort -unique $OFYA(LISTOF,FULLOS)]
    set OFYA(LISTOF,FULLNAME) [lsort -unique $OFYA(LISTOF,FULLNAME)]
    set OFYA(LISTOF,FILENAME) [lsort -unique $OFYA(LISTOF,FILENAME)]
    set OFYA(LISTOF,STRAIN)   [lsort -unique $OFYA(LISTOF,STRAIN)]
    foreach FullOS $OFYA(LISTOF,FULLOS) {
	lassign [split $FullOS "_"] G E
	set OS "$G $E"
	lappend OFYA(LISTOF,OS) $OS
    }     
    return [OrganismFromYannis $Qui $Quoi]
}

proc FromOrthoInspector {{Qui ""} {Quoi ""}} {
    #rR Lit les fasta de OrthoInspector
    #rR 
    global FromOrthoInspector

    set Qui  [string toupper $Qui]
    set Quoi [string toupper $Quoi]

    if {[info exists FromOrthoInspector($Qui,$Quoi)]}  { return $FromOrthoInspector($Qui,$Quoi) }
    if {[info exists FromOrthoInspector("EstCharge")]} {
	if {[info exists FromOrthoInspector($Qui,ID)]} {
	    set ID [string toupper $FromOrthoInspector($Qui,ID)]
	    if {[info exists FromOrthoInspector($ID,$Quoi)]} { return $FromOrthoInspector($ID,$Quoi) }
	}
	if {[info exists FromOrthoInspector($Qui,TAXID)]} {
	    set TID $FromOrthoInspector($Qui,TAXID)
	    if {[info exists FromOrthoInspector($TID,$Quoi)]} { return $FromOrthoInspector($TID,$Quoi) }
	}
	return ""
    }
    set FromOrthoInspector("EstCharge") 1
    
    set OnGarde 0
    
    set Rep [OrganismFromOrthoInspector Rep]
    
    set FromOrthoInspector(REP,) $Rep
    set LesTaxId [OrganismFromOrthoInspector ListOf TaxId]

    set Testons 0                                                            ;#rR pour test ********
    if {$Testons} { set LesTaxId [list 9606 9823 764100 4577 6182 7668] }

    set FromOrthoInspector(LISTOF,TAXID) [join $LesTaxId "\n"]
    foreach TaxId $LesTaxId {
	set OsDuFichier [OrganismFromOrthoInspector $TaxId FullOs]
	set OsCourtDuFichier [OrganismFromOrthoInspector $TaxId Os]
	lappend FromOrthoInspector(LISTOF,FULLOS) $OsDuFichier
	set FromOrthoInspector($TaxId,FULLOS) $OsDuFichier 
	set Fichier [OrganismFromOrthoInspector $TaxId Filename]
	set Queue [file tail $Fichier]
	set LeTFACourant {}
	set LesLignes [LesLignesDuFichier $Fichier]
	lappend LesLignes ">CESTFINIPOURCEFICHIER"
	set OsDansFichier ""
	set MaxiPourTestons 100 ;#rR 100 ou -1 pour tout
	if {[info exists Courant]} { unset Courant }
	foreach Ligne $LesLignes {

	    if {$Testons && [incr MaxiPourTestons -1]==0} { break }

	    regsub -all " +" $Ligne " " Ligne
	    set Ligne [string trim $Ligne]
	    if {$Ligne==""} { continue }
	    #rR dans sequence
	    if { ! [regexp "^>" $Ligne]} {
		if {[regexp -nocase {[^A-Z]} $Ligne]} {
		    if {[string index $Ligne end]=="*"} { set Ligne [string range $Ligne 0 end-1] }
		    if {[regexp -nocase {[^A-Z\*]} $Ligne Match]} {
			#rR la, il y a meme autre chose
			lappend FromOrthoInspector(LISTOF,BAD) "$Queue $Courant $Ligne"
			FaireLire "Dans $Queue $Courant \n$Ligne"
			set OnGarde 0
			continue
		    }
		    if {[regexp -nocase {\*} $Ligne Match]} {
			#FaireLire "Dans $Queue $Courant \n$Ligne"
			lappend FromOrthoInspector(LISTOF,OSWHITHSTAR) $Queue
			lappend FromOrthoInspector($TaxId,STAR) $Courant
			set OnGarde 0
			continue
		    }
		}
		if {$Ligne!=""} {
		    set OnGarde 1
		    lappend LeTFACourant $Ligne
		}
		continue
	    }
	    
	    #rR on a un chevron
	    
	    #rR on traite d'abord le précédent
	    if {[info exists Courant]} {
		if {$OnGarde} {
		    set ID [string toupper $Id]
		    set COURANT [string toupper $Courant]
		    set FromOrthoInspector($COURANT,TFA) [join $LeTFACourant "\n"]
		    set FromOrthoInspector($ID,ID)     $Id
		    set FromOrthoInspector($ID,AC)     $Ac
		    lappend FromOrthoInspector(LISTOF,IDS)     $Id
		    lappend FromOrthoInspector(LISTOF,ACS)     $Ac
		    lappend FromOrthoInspector($TaxIdDuCourant,IDS) $Id
		    lappend FromOrthoInspector($TaxIdDuCourant,ACS) $Ac
		    set FromOrthoInspector($ID,TAXID) $TaxIdDuCourant
		}
	    }
	    if {$Ligne==">CESTFINIPOURCEFICHIER"} { break }
	    
	    #rR on traite l'entête
	    if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} {
		FaireLire "pas bon $Ligne"
		lappend LeNew $Ligne
		continue
	    }
	    set TexteBanque ""
	    if {[regexp {\|} $Ligne]} {
		regexp {^>([^ ]+) (.+)} $Ligne Match AI D
		set Banque ""
		set Ac ""
		set Id ""
		lassign [split $AI "|"] Banque Ac Id
		if {$Ac==""} { set Ac $AI }
		if {$Id==""} { set Id $Ac }
		regsub {OS=.*} $D ""  D
		regsub {GN=.*} $D ""  D
		regsub -all ";" $D " " D
		set D [string trim $D " _,"]
		if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
		    set W $Id
		    set Id $Ac
		    set Ac $W
		}
		if {$Banque!=""} { set TexteBanque " BANK=$Banque" }
	    } else {
		regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac D
		regsub {OS=.*} $D ""  D
		regsub {GN=.*} $D ""  D
		regsub -all ";" $D " " D
		set D [string trim $D " _,"]
		if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
		    set W $Id
		    set Id $Ac
		    set Ac $W
		}
		#rR Traitement spécial pour lui ....................... il y a tr ou gn à la fin des Id ou Ac
		if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Id "" Id }
		if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Ac "" Ac }
	    }
	    
	    set Gn ""
	    regexp {GN=([^ ]+)} $Ligne Match Gn 
	    set TextGn ""
	    if {$Gn!=""} { set TextGn " GN=$Gn" }

	    
	    regsub { (GN|PE|SV)=.*} $Ligne "" LigneSansGN
	    set FullOs "Unknown unknown"
	    set OsDansEntete ""
	    if {[regexp { OS=(.+)} $LigneSansGN Match FullOs]} {
		regsub -all " " $FullOs "_" FullOs
		regsub -all "/" $FullOs "and" FullOs
		set OsDansEntete $FullOs
	    }
	    lassign [split $FullOs "_"] G E

	    set Entete ">$Id $Ac $G $E $D $TextGn OS=$OsDuFichier TAXID=$TaxId$TexteBanque"	    

	    set LeTFACourant [list $Entete]
	    if {$OsDansEntete==""} { set OsDansFichier $FullOs }
	    if {$OsDansEntete!=$OsDuFichier && $OsDansEntete!=$OsCourtDuFichier} {
		set Message "Dans $Queue\n$OsDansEntete differe de \n$OsDuFichier\n\n$OsDansEntete differe de \n$OsCourtDuFichier"
		if {0 &&  ! [info exists MessageLu($Message)]} {
		    FaireLire "$Message"
		    set  MessageLu($Message) 1
		} 
	    }
	    set Courant $Id
	    set COURANT [string toupper $Courant]
	    set TaxIdDuCourant $TaxId
	    set ID [string toupper $Id]
	    set AC [string toupper $Ac]
	    if {$ID!=$AC} { set FromOrthoInspector($AC,ID) $ID }
	    set FromOrthoInspector($ID,FULLOS) $FullOs
	    set FULLOS [string toupper $FullOs]
	    set FromOrthoInspector($FULLOS,TAXID) $TaxId
	}

	set FromOrthoInspector([string toupper $OsDuFichier],TAXID) $TaxId
    }
    set FromOrthoInspector(LISTOF,STAR) {}
    set FromOrthoInspector(LISTOF,COUNTSTAR) {}
    foreach TaxId $LesTaxId {
	if { ! [info exists FromOrthoInspector($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue } 
	set FullOs $FromOrthoInspector($TaxId,FULLOS)
	lappend FromOrthoInspector(LISTOF,TAXIDOS) "${TaxId}_$FullOs" 
	set nOK [llength $FromOrthoInspector($TaxId,IDS)]
	lappend FromOrthoInspector(LISTOF,COUNT) "$nOK $TaxId $FullOs"
	if {[info exists FromOrthoInspector($TaxId,STAR)]} {
	    set nKO [llength $FromOrthoInspector($TaxId,STAR)]
	    lappend FromOrthoInspector(LISTOF,COUNTSTAR) "$nKO $nOK $TaxId $FullOs"
	}
    }
    set FromOrthoInspector(LISTOF,TAXIDOS)   [join $FromOrthoInspector(LISTOF,TAXIDOS) "\n"]
    set FromOrthoInspector(LISTOF,FULLOS)    [join $FromOrthoInspector(LISTOF,FULLOS) "\n"]
    set FromOrthoInspector(LISTOF,COUNT)     [join $FromOrthoInspector(LISTOF,COUNT) "\n"]
    set FromOrthoInspector(LISTOF,STAR)      [join $FromOrthoInspector(LISTOF,STAR) "\n"]
    set FromOrthoInspector(LISTOF,COUNTSTAR) [join $FromOrthoInspector(LISTOF,COUNTSTAR) "\n"]
    return [FromOrthoInspector $Qui $Quoi]
}

proc FromYannis {{Qui ""} {Quoi ""}} {
    #rR Lit les fasta de Yannis
    #rR en utilisant OrganismFromYannis qui lit tous les ficheirs d'un repertoire
    global FromYannis

    set Qui  [string toupper $Qui]
    set Quoi [string toupper $Quoi]

    if {[info exists FromYannis($Qui,$Quoi)]}  { return $FromYannis($Qui,$Quoi) }
    if {[info exists FromYannis("EstCharge")]} {
	if {[info exists FromYannis($Qui,ID)]} {
	    set ID [string toupper $FromYannis($Qui,ID)]
	    if {[info exists FromYannis($ID,$Quoi)]} { return $FromYannis($ID,$Quoi) }
	}
	if {[info exists FromYannis($Qui,TAXID)]} {
	    set TID $FromYannis($Qui,TAXID)
	    if {[info exists FromYannis($TID,$Quoi)]} { return $FromYannis($TID,$Quoi) }
	}
	return ""
    }
    set FromYannis("EstCharge") 1
    
    set OnGarde 0
    
    set Rep [OrganismFromYannis Rep]
    
    set FromYannis(REP,) $Rep
    set LesTaxId [OrganismFromYannis ListOf TaxId]

    set Testons 0                                                            ;#rR pour test ********
    if {$Testons} { set LesTaxId [list 9606 9823 764100 4577 6182 7668] }

    set FromYannis(LISTOF,TAXID) [join $LesTaxId "\n"]
    foreach TaxId $LesTaxId {
	set OsDuFichier [OrganismFromYannis $TaxId FullOs]
	set OsCourtDuFichier [OrganismFromYannis $TaxId Os]
	lappend FromYannis(LISTOF,FULLOS) $OsDuFichier
	set FromYannis($TaxId,FULLOS) $OsDuFichier 
	set Fichier [OrganismFromYannis $TaxId Filename]
	set Queue [file tail $Fichier]
	set LeTFACourant {}
	set LesLignes [LesLignesDuFichier $Fichier]
	lappend LesLignes ">CESTFINIPOURCEFICHIER"
	set OsDansFichier ""
	set MaxiPourTestons 100 ;#rR 100 ou -1 pour tout
	if {[info exists Courant]} { unset Courant }
	foreach Ligne $LesLignes {

	    if {$Testons && [incr MaxiPourTestons -1]==0} { break }

	    regsub -all " +" $Ligne " " Ligne
	    set Ligne [string trim $Ligne]
	    if {$Ligne==""} { continue }
	    #rR dans sequence
	    if { ! [regexp "^>" $Ligne]} {
		if {[regexp -nocase {[^A-Z]} $Ligne]} {
		    if {[string index $Ligne end]=="*"} { set Ligne [string range $Ligne 0 end-1] }
		    if {[regexp -nocase {[^A-Z\*]} $Ligne Match]} {
			#rR la, il y a meme autre chose
			lappend FromYannis(LISTOF,BAD) "$Queue $Courant $Ligne"
			FaireLire "Dans $Queue $Courant \n$Ligne"
			set OnGarde 0
			continue
		    }
		    if {[regexp -nocase {\*} $Ligne Match]} {
			#FaireLire "Dans $Queue $Courant \n$Ligne"
			lappend FromYannis(LISTOF,OSWHITHSTAR) $Queue
			lappend FromYannis($TaxId,STAR) $Courant
			set OnGarde 0
			continue
		    }
		}
		if {$Ligne!=""} {
		    set OnGarde 1
		    lappend LeTFACourant $Ligne
		}
		continue
	    }
	    
	    #rR on a un chevron
	    
	    #rR on traite d'abord le précédent
	    if {[info exists Courant]} {
		if {$OnGarde} {
		    set ID [string toupper $Id]
		    set COURANT [string toupper $Courant]
		    set FromYannis($COURANT,TFA) [join $LeTFACourant "\n"]
		    set MemoTaxId $MemoTaxIdDuCourant($COURANT)
		    set FromYannis($ID,ID)     $Id
		    set FromYannis($ID,AC)     $Ac
		    lappend FromYannis(LISTOF,IDS)     $Id
		    lappend FromYannis(LISTOF,ACS)     $Ac
		    lappend FromYannis($MemoTaxId,IDS) $Id
		    lappend FromYannis($MemoTaxId,ACS) $Ac
		    set FromYannis($ID,TAXID) $MemoTaxId
		}
	    }
	    if {$Ligne==">CESTFINIPOURCEFICHIER"} { break }
	    
	    #rR on traite l'entête
	    if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} {
		FaireLire "pas bon $Ligne"
		lappend LeNew $Ligne
		continue
	    }
	    set TexteBanque ""
	    if {[regexp {\|} $Ligne]} {
		regexp {^>([^ ]+) (.+)} $Ligne Match AI D
		set Banque ""
		set Ac ""
		set Id ""
		lassign [split $AI "|"] Banque Ac Id
		if {$Ac==""} { set Ac $AI }
		if {$Id==""} { set Id $Ac }
		regsub {OS=.*} $D ""  D
		regsub {GN=.*} $D ""  D
		regsub -all ";" $D " " D
		set D [string trim $D " _,"]
		if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
		    set W $Id
		    set Id $Ac
		    set Ac $W
		}
		if {$Banque!=""} { set TexteBanque " BANK=$Banque" }
	    } else {
		regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac D
		regsub {OS=.*} $D ""  D
		regsub {GN=.*} $D ""  D
		regsub -all ";" $D " " D
		set D [string trim $D " _,"]
		if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
		    set W $Id
		    set Id $Ac
		    set Ac $W
		}
		#rR Traitement spécial pour lui ....................... il y a tr ou gn à la fin des Id ou Ac
		if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Id "" Id }
		if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Ac "" Ac }
	    }
	    
	    set Gn ""
	    regexp {GN=([^ ]+)} $Ligne Match Gn 
	    set TextGn ""
	    if {$Gn!=""} { set TextGn " GN=$Gn" }

	    
	    regsub { (GN|PE|SV)=.*} $Ligne "" LigneSansGN
	    set FullOs "Unknown unknown"
	    set OsDansEntete ""
	    if {[regexp { OS=(.+)} $LigneSansGN Match FullOs]} {
		regsub -all " " $FullOs "_" FullOs
		regsub -all "/" $FullOs "and" FullOs
		set OsDansEntete $FullOs
	    }
	    lassign [split $FullOs "_"] G E

	    set Entete ">$Id $Ac $G $E $D $TextGn OS=$OsDuFichier TAXID=$TaxId$TexteBanque"	    

	    set LeTFACourant [list $Entete]
	    if {$OsDansEntete==""} { set OsDansFichier $FullOs }
	    if {$OsDansEntete!=$OsDuFichier && $OsDansEntete!=$OsCourtDuFichier} {
		set Message "Dans $Queue\n$OsDansEntete differe de \n$OsDuFichier\n\n$OsDansEntete differe de \n$OsCourtDuFichier"
		if {0 &&  ! [info exists MessageLu($Message)]} {
		    FaireLire "$Message"
		    set  MessageLu($Message) 1
		} 
	    }
	    set Courant $Id
	    set COURANT [string toupper $Courant]
	    set MemoTaxIdDuCourant($COURANT) $TaxId
	    set ID [string toupper $Id]
	    set AC [string toupper $Ac]
	    if {$ID!=$AC} { set FromYannis($AC,ID) $ID }
	    set FromYannis($ID,FULLOS) $FullOs
	    set FULLOS [string toupper $FullOs]
	    set FromYannis($FULLOS,TAXID) $TaxId
	}

	set FromYannis([string toupper $OsDuFichier],TAXID) $TaxId
    }
    set FromYannis(LISTOF,STAR) {}
    set FromYannis(LISTOF,COUNTSTAR) {}
    foreach TaxId $LesTaxId {
	if { ! [info exists FromYannis($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue } 
	set FullOs $FromYannis($TaxId,FULLOS)
	lappend FromYannis(LISTOF,TAXIDOS) "${TaxId}_$FullOs" 
	set nOK [llength $FromYannis($TaxId,IDS)]
	lappend FromYannis(LISTOF,COUNT) "$nOK $TaxId $FullOs"
	if {[info exists FromYannis($TaxId,STAR)]} {
	    set nKO [llength $FromYannis($TaxId,STAR)]
	    lappend FromYannis(LISTOF,COUNTSTAR) "$nKO $nOK $TaxId $FullOs"
	}
    }
    set FromYannis(LISTOF,TAXIDOS)   [join $FromYannis(LISTOF,TAXIDOS) "\n"]
    set FromYannis(LISTOF,FULLOS)    [join $FromYannis(LISTOF,FULLOS) "\n"]
    set FromYannis(LISTOF,COUNT)     [join $FromYannis(LISTOF,COUNT) "\n"]
    set FromYannis(LISTOF,STAR)      [join $FromYannis(LISTOF,STAR) "\n"]
    set FromYannis(LISTOF,COUNTSTAR) [join $FromYannis(LISTOF,COUNTSTAR) "\n"]
    return [FromYannis $Qui $Quoi]
}

proc RajouteCrEnFinDeFasta {} {
    set Rep "/biolo/orthoinspector/DataOrthoinspector/Orthoinspector_v2/eukaryota/all"
    foreach Fichier [lsort [glob -nocomplain "$Rep/*.fasta"]] {
	set Queue [file tail $Fichier]
	set f [open $Fichier "a+"]
	set Texte [read $f]
	if {[string index $Texte end]=="\n"} { close $f; continue }
	puts $f ""
	Espionne $Queue
	close $f
    }
}

proc CreeUneBanqueBlastPAL {{LesOsChoisis ""} {Banque ""} {Dir ""}} {
    #rR on suppose que les .phr existent déjà. 
    #rR LesOsChoisis sont une liste de TaxId qui figurent en fin du nom des fichiers .phr

    set LesOSTaxId {}
    set LesOS      {}
    set LesTaxId   {}

    if {$Banque==""} { set Banque "BlastDatabase_[Date]" } 


    if {$Dir!=""} { set Dir "[RepertoireDuGenome]/banques" }
    NousAllonsAuBoulot $Dir
    foreach Fichier [lsort [glob -nocomplain "*.phr"]] {
	regsub ".phr$" $Fichier "" OSTaxId
	if { ! [regexp {([A-Z][a-z]+_[a-z\.]+)_([0-9]+)$} $OSTaxId Match OS TaxId]} { continue }
	lappend LesOSTaxId $OSTaxId
	lappend LesOS      $OS
	lappend LesTaxId   $TaxId
	set OSTaxIdDu($TaxId)   $OSTaxId
	set OSTaxIdDu($OSTaxId) $OSTaxId
    }
    if {$LesOsChoisis==""} { set LesOsChoisis [OrganismListForCilioCode "TaxId"] }
    if {$LesOsChoisis==""} { set LesOsChoisis [split [Affiche $LesOSTaxId "AvecRetour" "Select_the_organisms_and_press_Validate"] "\n"] }
    
    if {$LesOsChoisis==""} { return "" }
    
    set LesFichiersChoisis {} 
    foreach Choix $LesOsChoisis {
	if { ! [info exists OSTaxIdDu($Choix)]} {
	    set  OsName [Tax $Choix]
	    if {$OsName!=""} {
		set iUnder [string first " " $OsName]
Espionne $iUnder
		set Debut [string range $OsName 0 [incr iUnder -1]]
		Espionne $Debut
		set PhrTrouves [glob -nocomplain "$Debut*.phr"]
		if {$PhrTrouves!=""} {
		    set PhrRemplace ""
		    if {[llength $PhrTrouves]==1} {
			if {[OuiOuNon "I couldn't find $Choix $OsName\n Can I use \n$PhrTrouves\n"]} {
			    set PhrRemplace $PhrTrouves
			}
		    } else {
			if {[OuiOuNon "I couldn't find $Choix $OsName\n Ok to coose within\n$PhrTrouves\n"]} {
			    set PhrRemplace [ChoixParmi $PhrTrouves]
			}
		    }
		    if {$PhrRemplace!=""} {
			regsub ".phr$" $PhrRemplace "" Secours
			lappend LesFichiersChoisis $Secours
			continue
		    }
		}
	    }
	    Espionne "I can not find $Choix   I'll skip it. Sorry"
	    continue
	}
	lappend LesFichiersChoisis $OSTaxIdDu($Choix)
    }
    if {$LesFichiersChoisis==""} { return "" }
    
    set LeTextePal {}
    lappend LeTextePal "#"
    lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastPAL"
    lappend LeTextePal "#"
    lappend LeTextePal "#"
    lappend LeTextePal "TITLE $Banque"
    lappend LeTextePal "#"
    
    
    set LePal $LesFichiersChoisis
    set LePal [lsort -unique $LePal]
    set Pal [join $LePal " "]
    lappend LeTextePal "DBLIST $Pal"
    lappend LeTextePal "#"
    set BanqueCreee [SauveLesLignes $LeTextePal dans "$Banque.pal"]
    
    OnRevientDuBoulot

    return "$Dir/$BanqueCreee"
}

proc CreeUneBanqueBlastAvecYannis {{LesOsChoisis ""} {Banque ""} {Separate ""}} {
    #rR a parfaire !!!!!!!!!!!!!!!!!! pour aller chercher les banques dans /biolo/orthoinspector/.../proteomes ou ils existent déjà

    if {$Separate==""} { set Separate "Separate" }
    set Separate [regexp -nocase "Separ" $Separate]

    set Dir ""
    if {$Banque==""} { set Banque "Proteome" } 
    if {[regexp "/" $Banque]} {
	set Dir [file dirname $Banque]
	set Banque [file tail $Banque]
    }
    if {$Dir==""} { set Dir "[RepertoireDuGenome]/banques" } 
    file mkdir $Dir

    if {$LesOsChoisis==""} {
	set LesOS [FromYannis ListOf TaxIdOs]	
	set Choisis [Affiche $LesOS "AvecRetour" "Select_the_organisms_and_press_Validate"]
	set LesOsChoisis [split $Choisis "\n"]
    }
    if {[string equal -nocase "All" $LesOsChoisis]} {
	set LesOsChoisis [split [FromYannis ListOf TaxIdOs] "\n"]
    }


    NousAllonsAuBoulot $Dir

    set LePal {}

    if {$Separate} {
	lappend LeTextePal "#"
	lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastAvecYannis"
	lappend LeTextePal "#"
	lappend LeTextePal "#"
	lappend LeTextePal "TITLE $Banque"
	lappend LeTextePal "#"
    }


    set LeGrosTfa {}
    foreach OS $LesOsChoisis {
	set TaxId ""; set G ""; set E ""
	lassign [split $OS "_"] TaxId G E
	if {$TaxId=="" || $G=="" || $E==""} { FaireLire "$OS is wrong I'll skip" ; continue }
	set GET "${G}_${E}_${TaxId}"
	set i 0
	set LePetitTfa {}
	foreach ID [FromYannis $TaxId IDs] {
	    set ID [string toupper $ID]
	    if {[info exists DejaVu($ID)]} { FaireLire "Deja vu $ID"; continue }
	    set TFA [FromYannis $ID TFA]
	    if {$TFA==""} { continue }
	    if {$Separate} {
		lappend LePetitTfa $TFA
		lappend LePal $GET
	    } else {
		lappend LeGrosTfa $TFA
	    }
	    incr i
	}
	AppendAuFichier ${Banque}_TaillesDesOs.txt "$i $GET"
	if {$Separate && ! [file exists $GET.phr]} {
	    SauveLesLignes $LePetitTfa dans $GET
	    exec formatdb -i $GET -p T
	}
    }
    set LePal [lsort -unique $LePal]
    if {$Separate} {
	set Pal [join $LePal " "]
	lappend LeTextePal "DBLIST $Pal"
	lappend LeTextePal "#"
	SauveLesLignes $LeTextePal dans "$Banque.pal"
    } else {
	while {[glob -nocomplain $Banque]!={} || [glob -nocomplain $Banque.*]!={}} {
	    if {[OuiOuNon "Attention. Some files with the same name already exist.\nPlease verify and remove them if necessary\nDo I overwrite"]} {
		break
	    }
	    if {[OuiOuNon "Do I stop creating the BlastDatabase"]} { return "" }
	}
	SauveLesLignes $LeGrosTfa dans $Banque
	exec formatdb -i $Banque -p T
    }
    OnRevientDuBoulot

    return "$Dir/$Banque"
}

proc CreeUneBanqueBlastAvecOrthoInspector {{LesOsChoisis ""} {Banque ""} {Separate ""}} {
    #rR a parfaire !!!!!!!!!!!!!!!!!! pour aller chercher les banques dans /biolo/orthoinspector/.../proteomes ou ils existent déjà

    if {$Separate==""} { set Separate "Separate" }
    set Separate [regexp -nocase "Separ" $Separate]

    set Dir ""
    if {$Banque==""} { set Banque "FromOI" } 
    if {[regexp "/" $Banque]} {
	set Dir [file dirname $Banque]
	set Banque [file tail $Banque]
    }
    if {$Dir==""} { set Dir "[RepertoireDuGenome]/banques" } 
    file mkdir $Dir

    if {$LesOsChoisis==""} {
	set LesOS [FromOrthoInspector ListOf TaxIdOs]	
	set Choisis [Affiche $LesOS "AvecRetour" "Select_the_organisms_and_press_Validate"]
	set LesOsChoisis [split $Choisis "\n"]
    }
    if {[string equal -nocase "All" $LesOsChoisis]} {
	set LesOsChoisis [split [FromOrthoInspector ListOf TaxIdOs] "\n"]
    }


    NousAllonsAuBoulot $Dir

    set LePal {}

    if {$Separate} {
	lappend LeTextePal "#"
	lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastAvecOrthoInspector"
	lappend LeTextePal "#"
	lappend LeTextePal "#"
	lappend LeTextePal "TITLE $Banque"
	lappend LeTextePal "#"
    }


    set LeGrosTfa {}
    foreach OS $LesOsChoisis {
	set TaxId ""; set G ""; set E ""
	lassign [split $OS "_"] TaxId G E
	if {$TaxId=="" || $G=="" || $E==""} { FaireLire "$OS is wrong I'll skip" ; continue }
	set GET "${G}_${E}_${TaxId}"
	set i 0
	set LePetitTfa {}
	foreach ID [FromOrthoInspector $TaxId IDs] {
	    set ID [string toupper $ID]
	    if {[info exists DejaVu($ID)]} { FaireLire "Deja vu $ID"; continue }
	    set TFA [FromOrthoInspector $ID TFA]
	    if {$TFA==""} { continue }
	    if {$Separate} {
		lappend LePetitTfa $TFA
		lappend LePal $GET
	    } else {
		lappend LeGrosTfa $TFA
	    }
	    incr i
	}
	AppendAuFichier ${Banque}_TaillesDesOs.txt "$i $GET"
	if {$Separate && ! [file exists $GET.phr]} {
	    SauveLesLignes $LePetitTfa dans $GET
	    exec formatdb -i $GET -p T
	}
    }
    set LePal [lsort -unique $LePal]
    if {$Separate} {
	set Pal [join $LePal " "]
	lappend LeTextePal "DBLIST $Pal"
	lappend LeTextePal "#"
	SauveLesLignes $LeTextePal dans "$Banque.pal"
    } else {
	while {[glob -nocomplain $Banque]!={} || [glob -nocomplain $Banque.*]!={}} {
	    if {[OuiOuNon "Attention. Some files with the same name already exist.\nPlease verify and remove them if necessary\nDo I overwrite"]} {
		break
	    }
	    if {[OuiOuNon "Do I stop creating the BlastDatabase"]} { return "" }
	}
	SauveLesLignes $LeGrosTfa dans $Banque
	exec formatdb -i $Banque -p T
    }
    OnRevientDuBoulot

    return "$Dir/$Banque"
}

proc CilioCartaDb {{Qui ""} {Quoi ""} {Value ""} {GetWhat ""}} {

    CanalSqlCilioCarta
#    set R [SqlExec "select name from sqlite_master" $Quoi]
#    set R [SqlExec "select * from prot where genename is not null limit 3" $Quoi]

    if {[regexp -nocase "ListOf" $Qui] && [regexp -nocase "Table" $Quoi]} {
	return [SqlExec "SELECT name FROM sqlite_master" "GetList"]
    }
    if {[regexp -nocase "Sql" $Qui] } {
	return [SqlExec "SELECT sql FROM sqlite_master WHERE name='$Quoi'" "GetFirstValue"]
    }
    if {[regexp "Columns" $Qui]} {
	set S [SqlExec "SELECT sql FROM sqlite_master WHERE name='$Quoi'" "GetFirstValue"]
	set LesMots [split [string trim [join [lrange [split $S " "] 3 end] " "] "()"] ","]
	set LeR {}
	set LesC {}
	foreach Mot $LesMots {
	    set Mot [string trim $Mot]
	    regsub " " $Mot "\t" Mot
	    lassign [split $Mot "\t"] N T
	    regsub -all {\"} $N "" N
	    lappend LeR [format "%-25s\t%s" $N $T]
	    lappend LesC $N
	}
	if {[regexp "ColumnsWith" $Qui]} { return $LeR }
	return $LesC
    }
    return [SqlExec "select * from $Qui where $Quoi like '$Value'" $GetWhat]    
}

proc FastaForBlast {{Qui ""} {Quoi ""} {FastaFile ""} {NewFastaFile ""}} {
    global FastaForBlast

    set RemovePipeFromHeader [OuiOuNon "Do I replace >sp|ac|id with >ID AC" 0 ]

    #rR on lit le fichier fasta fourni par Uniprot et si RemeovePipeFromHeader on modifie sp|ac|id en SPT:ID AC
    #rR on rajoute aussi OX=9606 en fin d'entete (attentio avant j'avais OX: ... !)
    #rR les statistiques peuvent se faire apres création du nouveau fasta avec StatFromFasta ci-dessous 

    set Qui  [string toupper $Qui]
    set Quoi [string toupper $Quoi]
    if {$Qui=="-"} { set Qui "" }
    if {$Quoi=="-"} { set Quoi "" }

    if {$FastaFile!=""} {
	if {[info exists FastaForBlast(FASTAFILE,)]} {
	    if {$FastaForBlast(FASTAFILE,)!=$FastaFile} {
		unset FastaForBlast
	    }
	}
	set FastaFileToSet $FastaFile
	set NewFastaFileToSet $NewFastaFile
    }


    if {[info exists FastaForBlast($Qui,$Quoi)]}  { return $FastaForBlast($Qui,$Quoi) }
    if {[info exists FastaForBlast("EstCharge")]} {
	if {[info exists FastaForBlast($Qui,ID)]} {
	    set ID [string toupper $FastaForBlast($Qui,ID)]
	    if {[info exists FastaForBlast($ID,$Quoi)]} { return $FastaForBlast($ID,$Quoi) }
	}
	if {[info exists FastaForBlast($Qui,TAXID)]} {
	    set TID $FastaForBlast($Qui,TAXID)
	    if {[info exists FastaForBlast($TID,$Quoi)]} { return $FastaForBlast($TID,$Quoi) }
	}
	return ""
    }
    if { ! [info exists FastaFileToSet]} {
	FaireLire "Please give the name of the FastaFile"
	return ""
    }
    set FastaForBlast(FASTAFILE,)       $FastaFileToSet
    set FastaForBlast(NEWFASTAFILE,) $NewFastaFileToSet
    set FastaForBlast("EstCharge") 1

    set FastaFile $FastaForBlast(FASTAFILE,)
    set Queue [file tail $FastaFile]

    set OnGarde 1
    set LeTFAACreer {}
    set FlushSize 10000
    set iFlush 0
    set DejaStocke 0

    if {$FastaForBlast(NEWFASTAFILE,)==""} {
	set CreateNew 0
    } else {
	set CreateNew 1
	if {[file exists $FastaForBlast(NEWFASTAFILE,)]} {
	    if {[OuiOuNon "$FastaForBlast(NEWFASTAFILE,)\n already exists. Do I overwrite"]} {
		file delete $FastaForBlast(NEWFASTAFILE,)
	    } else {
		if { ! [OuiOuNon "$FastaForBlast(NEWFASTAFILE,)\n already exists. Do I append"]} {
		    return ""
		}
	    }
	}
    }
    
    set MaxiPourTestons -10000 ;#rR 100 pour limité, -100 pour illimité
    
    set F [open $FastaForBlast(FASTAFILE,) "r"]
    while {1} {
	
	set OnBreak [expr [gets $F Ligne] < 0 ]
	
	if { ! $OnBreak } {
	    regsub -all " +" $Ligne " " Ligne
	    set Ligne [string trim $Ligne]
	    if {$Ligne==""} { continue }
	    #rR dans sequence
	    if { ! [regexp "^>" $Ligne]} {
		lappend LeTFAACreer $Ligne
		continue
	    }
	}
	
	#rR on a un chevron	
	#rR on traite d'abord le précédent
	if {[info exists Courant]} {
	    if {$OnGarde} {
		if {[incr MaxiPourTestons -1]==0} { set OnBreak 1 }
		set ID [string toupper $Id]
		set COURANT [string toupper $Courant]
		lappend FastaForBlast(LISTOF,IDS)     $Id
		lappend FastaForBlast(LISTOF,ACS)     $Ac
		lappend FastaForBlast($MemoTaxId,IDS) $Id
		lappend FastaForBlast($MemoTaxId,ACS) $Ac
		if { ! $CreateNew} {
		    #set FastaForBlast($COURANT,TFA) [join $LeTFACourant "\n"]
		    set FastaForBlast($ID,ID)     $Id
		    set FastaForBlast($ID,AC)     $Ac
		    set FastaForBlast($ID,TAXID) $MemoTaxId
		}
		incr iFlush
		if {$CreateNew && ($iFlush>=$FlushSize || ($iFlush>0 && $OnBreak))} {
		    AppendAuFichier $FastaForBlast(NEWFASTAFILE,) [join $LeTFAACreer "\n"]
		    incr DejaStocke $iFlush
		    Espionne "$DejaStocke sequences already done."
		    set LeTFAACreer {}
		    set iFlush 0
		}
	    }
	}
	if {$OnBreak} { break }
	
	#rR on traite l'entête
	if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} {
	    FaireLire "pas bon $Ligne"
	    lappend LeNew $Ligne
	    continue
	}
	set TexteTaxId ""
	if {[regexp {\|} $Ligne]} {
	    
	    #rR on espere >Banque|Ac|Id Definition... (attention à l'ordre)
	    set ResteDeLaLigne ""
	    regexp {^>([^ ]+) (.+)} $Ligne Match BAI ResteDeLaLigne
	    set Banque ""
	    set Ac ""
	    set Id ""
	    lassign [split $BAI "|"] Banque Ac Id
	    if {$Ac==""} { set Ac $BAI }
	    if {$Id==""} { set Id $Ac }
	    if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
		set W $Id
		set Id $Ac
		set Ac $W
	    }
	} else {
	    #rR on espere >Banque:Id Ac Definition... (Attention à l'ordre Id avant Ac)
	    set Banque ""
	    set Id ""
	    set Ac ""
	    set ResteDeLaLigne ""
	    regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac ResteDeLaLigne
	    if {[regexp {([^\:]+)\:(.+)} $Id Match B I]} {
		set Banque $B
		set Id $I
	    }
	    if {$Ac==""} { set Ac $Id }
	    if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
		set W $Id
		set Id $Ac
		set Ac $W
	    }
	}
	
	
	set TexteBanque ""
	# on laisse comme c'est  if {[string equal -nocase "sp" $Banque]} { set Banque "SW" }
	# on laisse comme c'est  if {[string equal -nocase "tr" $Banque]} { set Banque "TR" }
	#rR supprimé 20160708 ***************************************************	if {$Banque!=""} { set TexteBanque "$Banque:" }
	
	set Gn ""
	regexp {GN=([^ ]+)} $Ligne Match Gn 
	set TextGn ""
	if {$Gn!=""} { set TextGn " GN=$Gn" }
	
	
	set FullOs "Unknown unknown"
	if {[regexp { OS=(.+)} $Ligne Match FullOsWithJunk]} {
	    regsub {[A-Z][A-Z]=.*} $FullOsWithJunk "" FullOs
	    set FullOs [string trim $FullOs]
	}
	set TexteTaxId ""
	set TaxId [TaxParQdsMemo $FullOs]
	if {$TaxId!=""} {
	    lappend LesTaxId $TaxId
	    set TexteTaxId " OX=$TaxId"
	    set FastaForBlast($TaxId,FULLOS) $FullOs
	}
	
	if {$RemovePipeFromHeader} {
	    set Entete ">$TexteBanque$Id $Ac $ResteDeLaLigne$TexteTaxId"	    
	} else {
	    set Entete "$Ligne$TexteTaxId"
	}
	lappend LeTFAACreer $Entete
	
	set Courant $Id
	set COURANT [string toupper $Courant]
	set MemoTaxId $TaxId
	set ID [string toupper $Id]
	set AC [string toupper $Ac]
	if { ! $CreateNew} { 
	    if {$ID!=$AC} { set FastaForBlast($AC,ID) $ID }
	    set FastaForBlast($ID,FULLOS) $FullOs
	}
	set FULLOS [string toupper $FullOs]
	set FastaForBlast($FULLOS,TAXID) $TaxId
    }
    
    set LesTaxId [lsort -unique $LesTaxId]
    set FastaForBlast(LISTOF,TAXID) $LesTaxId
    
    foreach TaxId $LesTaxId {
	if { ! [info exists FastaForBlast($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue } 
	set FullOs $FastaForBlast($TaxId,FULLOS)
	lappend FastaForBlast(LISTOF,FULLOS)  "$FullOs" 
	lappend FastaForBlast(LISTOF,TAXIDOS) "${TaxId}_$FullOs" 
	set nOK [llength $FastaForBlast($TaxId,IDS)]
	lappend FastaForBlast(LISTOF,COUNT) "$nOK $TaxId $FullOs"
    }
    set FastaForBlast(LISTOF,TAXID)     [join $FastaForBlast(LISTOF,TAXID)   "\n"]
    set FastaForBlast(LISTOF,TAXIDOS)   [join $FastaForBlast(LISTOF,TAXIDOS) "\n"]
    set FastaForBlast(LISTOF,FULLOS)    [join $FastaForBlast(LISTOF,FULLOS)  "\n"]
    set FastaForBlast(LISTOF,COUNT)     [join $FastaForBlast(LISTOF,COUNT)   "\n"]
    
    if {$CreateNew} {
	set FichierStat "$FastaForBlast(NEWFASTAFILE,).stat"
	set FastaForBlast(STAT,FILENAME) [Sauve $FastaForBlast(LISTOF,COUNT) dans $FichierStat]
    }
    
    return [FastaForBlast $Qui $Quoi]
}

proc StatFromFasta {{Qui ""} {Quoi ""} {FastaFile ""} {StatFile ""} {ProcessAlsoId ""}} {
    global StatFromFasta

    set ProcessAlsoId [string equal -nocase $ProcessAlsoId "ProcessAlsoId"]

    set Qui  [string toupper $Qui]
    set Quoi [string toupper $Quoi]

    if {$FastaFile!=""} {
	if {[info exists StatFromFasta(FASTAFILE,)]} {
	    if {$StatFromFasta(FASTAFILE,)!=$FastaFile} {
		unset StatFromFasta
	    }
	}
	set StatFromFasta(FASTAFILE,) $FastaFile
	set StatFromFasta(STAFILE,)   $StatFile
    }

    if { ! [info exists StatFromFasta(FASTAFILE,)]} {
	FaireLire "Please give the name of the FastaFile"
	return ""
    }

    if {[info exists StatFromFasta($Qui,$Quoi)]}  { return $StatFromFasta($Qui,$Quoi) }
    if {[info exists StatFromFasta("EstCharge")]} {
	if {[info exists StatFromFasta($Qui,TAXID)]} {
	    set TID $StatFromFasta($Qui,TAXID)
	    if {[info exists StatFromFasta($TID,$Quoi)]} { return $StatFromFasta($TID,$Quoi) }
	}
	return ""
    }
    set StatFromFasta("EstCharge") 1

    set FastaFile $StatFromFasta(FASTAFILE,)

    set OnGarde 1

    set DejaFaits 0
    set MaxiPourTestons -1000 ;#rR 100 pour limité, -100 pour illimité
    
    set F [open $StatFromFasta(FASTAFILE,) "r"]
    while {1} {
	
	set  OnBreak [expr [gets $F Ligne] < 0 ]
	if {$OnBreak } { break }
	if { ! [regexp ">" $Ligne]} { continue }
	if {[incr MaxiPourTestons -1]==0} { break }

	regsub -all " +" $Ligne " " Ligne
	set Ligne [string trim $Ligne]

	if {[incr DejaFaits]%10000==0} { Espionne "$DejaFaits déjà faits" }

	if {[regexp {\|} $Ligne]} {
	    #rR normalement on a que le cas else si on a fait FastaForBlast
	    #rR on espere >Banque|Ac|Id Definition... (attention à l'ordre)
	    set ResteDeLaLigne ""
	    regexp {^>([^ ]+) (.+)} $Ligne Match BAI ResteDeLaLigne
	    set Banque ""
	    set Ac ""
	    set Id ""
	    lassign [split $BAI "|"] Banque Ac Id
	    if {$Ac==""} { set Ac $BAI }
	    if {$Id==""} { set Id $Ac }
	    if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
		set W $Id
		set Id $Ac
		set Ac $W
	    }
	} else {
	    #rR on espere >Banque:Id Ac Definition... (Attention à l'ordre Id avant Ac)
	    set Banque ""
	    set Id ""
	    set Ac ""
	    set ResteDeLaLigne ""
	    regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac ResteDeLaLigne
	    if {[regexp {([^\:]+)\:(.+)} $Id Match B I]} {
		set Banque $B
		set Id $I
	    }
	    if {$Ac==""} { set Ac $Id }
	    if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
		set W $Id
		set Id $Ac
		set Ac $W
	    }
	}
	
	set FullOs "Unknown unknown"
	if {[regexp { OS=(.+)} $Ligne Match FullOsWithJunk]} {
	    regsub {[A-Z][A-Z]=.*} $FullOsWithJunk "" FullOs
	    set FullOs [string trim $FullOs]
	}

	set TaxId [IntegerApres "OX=" dans $Ligne]
	if {$TaxId==""} {
	    set TaxId [IntegerApres "OX:" dans $Ligne]
	}
	if {$TaxId!=""} {
	    lappend LesTaxId $TaxId
	    set StatFromFasta($TaxId,FULLOS) $FullOs
	}
	
	set Courant $Id
	set COURANT [string toupper $Courant]
	set ID [string toupper $Id]
	set AC [string toupper $Ac]
	if {$ProcessAlsoId} { 
	    if {$ID!=$AC} { set StatFromFasta($AC,ID) $ID }
	    set StatFromFasta($ID,FULLOS) $FullOs
	}
	set FULLOS [string toupper $FullOs]
	set StatFromFasta($FULLOS,TAXID) $TaxId

	set ID [string toupper $Id]
	set COURANT [string toupper $Courant]
	lappend StatFromFasta(LISTOF,IDS) $Id
	lappend StatFromFasta(LISTOF,ACS) $Ac
	lappend StatFromFasta($TaxId,IDS) $Id
	lappend StatFromFasta($TaxId,ACS) $Ac
	if {$ProcessAlsoId} {
	    set StatFromFasta($ID,ID)     $Id
	    set StatFromFasta($ID,AC)     $Ac
	    set StatFromFasta($ID,TAXID)  $TaxId
	}
    }
    
    set LesTaxId [lsort -unique $LesTaxId]
    set StatFromFasta(LISTOF,TAXID) $LesTaxId
    
    foreach TaxId $LesTaxId {
	if { ! [info exists StatFromFasta($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue } 
	set FullOs $StatFromFasta($TaxId,FULLOS)
	lappend StatFromFasta(LISTOF,FULLOS)  "$FullOs" 
	lappend StatFromFasta(LISTOF,TAXIDOS) "${TaxId}_$FullOs" 
	set nOK [llength $StatFromFasta($TaxId,IDS)]
	lappend StatFromFasta(LISTOF,COUNT) "$nOK $TaxId $FullOs"
    }
    set StatFromFasta(LISTOF,TAXID)     [join $StatFromFasta(LISTOF,TAXID)   "\n"]
    set StatFromFasta(LISTOF,TAXIDOS)   [join $StatFromFasta(LISTOF,TAXIDOS) "\n"]
    set StatFromFasta(LISTOF,FULLOS)    [join $StatFromFasta(LISTOF,FULLOS)  "\n"]
    set StatFromFasta(LISTOF,COUNT)     [join $StatFromFasta(LISTOF,COUNT)   "\n"]
    
    if {$StatFile!=""} {
	set StatFromFasta(STAT,FILENAME) [Sauve $StatFromFasta(LISTOF,COUNT) dans $StatFile]
    }
    
    return [StatFromFasta $Qui $Quoi]
}

proc PdbInfo {{Qui ""} {Quoi ""}} {
    global PdbInfo

    if {[info exists PdbInfo($Qui,$Quoi)]} { return $PdbInfo($Qui,$Quoi) }
    if {[info exists PdbInfo("EstCharge")]} { return "" }
    set PdbInfo("EstCharge") 1

    set FichierProtnames "./protnames.lst"

    foreach Ligne [LesLignesDuFichier $FichierProtnames] {
	scan $Ligne "%s" Acc
	set PdbInfo($Acc,txt) $Ligne
	lappend PdbInfo(listof,acc) $Acc
	if {[regexp -nocase {^([0-9a-z]+) [\*\- ]+$} $Ligne Match Acc]} {
	    set PdbInfo($Acc,def) ""
	    continue
	}
	if {[regexp -nocase {^([0-9a-z]+) +\* +\- +\- +} $Ligne Match Acc]} {
	    regsub {^([0-9a-z]+) +\* +\- +\- +} $Ligne "" Def
	    set PdbInfo($Acc,def) [string trim $Def]
	    continue
	}
	set T ""
	set Date ""
	set Meth ""
	lassign [split $Ligne " "] Acc T Date Meth
	if { ! [regexp {^[0-9][0-9]\-[A-Z][a-z][a-z]\-[0-9][0-9]$} $Date]} {
	    if {[regexp {(X\-ray|NMR) +([0-9\.]+) (.+)$} $Ligne Match Meth Resol Def]} {
		set PdbInfo($Acc,def) [string trim $Def]
		set PdbInfo($Acc,met) [string trim $Meth]
		set PdbInfo($Acc,res) [string trim $Resol]
		continue
	    } 
	    if {[regexp {(Theoret model) (.+)$} $Ligne Match Meth Def]} {
		set PdbInfo($Acc,def) [string trim $Def]
		continue
	    }
	    FaireLire $Ligne
	    continue
	}
	if {$Meth==""} { set Meth "-" }
	regsub -all -- {\*} $T    "\\*" xT
	regsub -all -- {\-} $xT    "\\-" xT
	regsub -all -- {\-} $Date "\\-" xDate
	regsub -all -- {\-} $Meth "\\-" xMeth
	regsub "$Acc +$xT +$xDate +$xMeth" $Ligne "" ResDef
	scan $ResDef "%s" Resol
	regsub -all -- {\-} $Resol "\\-" Resol
	regsub -- "$Resol +" $ResDef "" Def

	if { ! [regexp {^[0-9\.]+$} $Resol]} { set Resol "" }

	set PdbInfo($Acc,def) [string trim $Def]
	set PdbInfo($Acc,dat) [string trim $Date]
	set PdbInfo($Acc,met) [string trim $Meth]
	set PdbInfo($Acc,res) [string trim $Resol]
    }

    foreach Acc [PdbInfo listof acc] {
	set Def $PdbInfo($Acc,def)
	if {[info exists PdbInfo($Acc,dat)]}                                  { append Def " $PdbInfo($Acc,dat)" }
	if {[info exists PdbInfo($Acc,met)] && $PdbInfo($Acc,met)!="Theoret"} { append Def " $PdbInfo($Acc,met)" }
	if {[info exists PdbInfo($Acc,res)]}                                  { append Def " $PdbInfo($Acc,res)" }
	set PdbInfo($Acc,def) $Def
    }

    return [PdbInfo $Qui $Quoi]
    
}

proc PdbSeqRes {{Qui ""} {Quoi ""}} {
    global PdbSeqRes

    if {[info exists PdbSeqRes($Qui,$Quoi)]} { return $PdbSeqRes($Qui,$Quoi) }
    if {[info exists PdbSeqRes("EstCharge")]} { return "" }
    set PdbSeqRes("EstCharge") 1

    set FichierSeqRes "./pdb_seqres.txt"

    foreach Ligne [LesLignesDuFichier $FichierSeqRes] {
	if {[regexp ">" $Ligne]} {
	    scan $Ligne "%s" AccChain
	    regsub ">" $AccChain "" AccChain
	    lappend PdbSeqRes(listof,acc) $AccChain
	    set PdbSeqRes($AccChain,seq) ""
	    regsub {.*length\:[0-9]+ +} $Ligne "" Titre
	    set PdbSeqRes($AccChain,tit) $Titre
	    continue
	}
	set Ligne [string trim $Ligne]
	append PdbSeqRes($AccChain,seq) $Ligne
    }
    foreach AccChain $PdbSeqRes(listof,acc) {
	regsub {_[A-Z]+} $AccChain "" Acc
	set acc [string tolower $Acc]
	set Def [PdbInfo $acc def]
	set Entete ">PDB:$AccChain $PdbSeqRes($AccChain,tit)."
	if {$Def!=""} { append Entete " $Def" }
	set Seq $PdbSeqRes($AccChain,seq)
	if {[regexp -nocase {[^a-z]} $Seq]} { Espionne "$Acc $Seq" }
	set Tfa [SequenceFormatTFA $Seq $Entete "protbrut"]
	set PdbSeqRes($AccChain,tfa) $Tfa
	set ACCCHAIN [string toupper $AccChain]
	if {$AccChain!=$ACCCHAIN} {
	    set PdbSeqRes($ACCCHAIN,tfa) $Tfa
	    set PdbSeqRes($ACCCHAIN,seq) $Seq
	}
    }
    return [PdbSeqRes $Qui $Quoi]
}

proc CreatePdbFromSeqResAndProtName {{Sortie ""}} {
    foreach Acc [PdbSeqRes listof acc] {
	set Tfa [PdbSeqRes $Acc tfa]
	lappend LeTfa $Tfa
    }
    set GrosTfa [join $LeTfa "\n"]
    if {$Sortie==""} {return $GrosTfa }
    return [Sauve $GrosTfa dans $Sortie] 
}

proc BonneEntetePourBilanCilio Header {
    global BonneEntetePourBilanCilio
    set HEADER [string toupper $Header]
    if {[info exists BonneEntetePourBilanCilio($HEADER)]} { return $BonneEntetePourBilanCilio($HEADER) }
    if {[info exists BonneEntetePourBilanCilio("EstCharge")]} { return $Header }
    set BonneEntetePourBilanCilio("EstCharge") 1

    set LookupList [list \
			"In_GoldStandard"         "InGoldStandard"       \
			"GScope"                  "GscopeId"             \
			"Uniprot ID"              "UniprotId"            \
			"In orthoinspector"       "InOrthoinspector"     \
			"Groupe de paralogue"     "GroupOfParalog"       \
			"GO"                      -                      \
			"Function"                -                      \
			"Citation"                -                      \
			"ProteinName"             -                      \
			"Uniprot Total"           "UniprotTotal"         \
			"Genomique comparative"   "ComparativeGenomics"  \
			"Proteomique"             -                      \
			"Transcriptomique"        "Trasncriptomics"      \
			"Promoteur X-Box"         "PromoteurX-Box"       \
			"Total"                   -                      \
			"Prediction"              -                      \
			"Phylum specific"         "PhylumSpecific"       \
			"Ciliated-specific"       "CiliatedSpecific"     \
			"Diff Stramenopile"       "DiffStramenopile"     \
			"Diff Archaeplastidae"    "Diff Archaeplastidae" \
			"Diff Alveolata"          "DiffAlveolata"        \
			"Diff Fungi"              "DiffFungi"            \
			"Nb de clades ciliés"     "NbCladesCilies"       \
			"Nb de clades non ciliés" "NbCladesNonCilies"    \
			"Nb de PR"                "NbPR"                 \
			"Universal"               "Universal"            \
			"Nb Diff"                 "NbDiff"               \
		       ]
    foreach {K V} $LookupList {
	if {$V=="-"} { set V $K }
	set BonneEntetePourBilanCilio([string toupper $K]) $V
    }
    return [BonneEntetePourBilanCilio $Header]
}

proc BilanCilio2014 {{Qui ""} {Quoi ""}} {
    global BilanCilio2014

    #rR on lit le fichier Excel de Odile
    #rR gscope puts BilanCilio2014 ListOf Usage

    if {[info exists BilanCilio2014($Qui,$Quoi)]} { return $BilanCilio2014($Qui,$Quoi) }
    if {[info exists BilanCilio2014("EstCharge")]} {
	if {$Qui=="ListOf" && $Quoi=="Example"} {
	    set LesExemples {}
	    foreach Us $BilanCilio2014(ListOf,Usage) {
		if { ! [regexp "^Bilan" $Us]} { continue }
		lappend LesExemples "\n$Us"
		lappend LesExemples [eval $Us]
	    }
	    lappend LesExemples "\nYou can run all these commands with :"
	    lappend LesExemples "gscope puts BilanCilio2014 Y_Mammalia TaxId"
	    return [join $LesExemples "\n"]
	}		
	return ""
    }
    set BilanCilio2014("EstCharge") 1


    set Fichier "[RepertoireDuGenome]/fiches/bilan_presence_absence_avecgroupes_tentativescriteres.csv"
    if {[FileAbsent $Fichier]} { unset BilanCilio2014; return "" }
    set BilanCilio2014(exists,) 1

    set Usage [list \
		   "gscope puts BilanCilio2014 ListOf Usage" \
		   "BilanCilio2014 ListOf Box" \
		   "BilanCilio2014 ListOf Access" \
		   "BilanCilio2014 ListOf Categories" \
		   "BilanCilio2014 ListOf TaxId" \
		   "BilanCilio2014 ListOf Class" \
		   "BilanCilio2014 ListOf Clade" \
		   "" \
		   "BilanCilio2014 10090  Class" \
		   "BilanCilio2014 10090  Clade" \
		   "BilanCilio2014 10090  State" \
		   "BilanCilio2014 10090  PA" \
		   "" \
		   "BilanCilio2014 Y_Mammalia TaxId" \
		   "BilanCilio2014 Y_Mammalia State" \
		   "BilanCilio2014 Y_Mammalia States" \
		   "BilanCilio2014 Y_Mammalia Count" \
		   "BilanCilio2014 Y_Mammalia PA" \
		   "" \
	       ]
    set BilanCilio2014(ListOf,Usage) $Usage

    set BilanCilio2014(Filename,) $Fichier 

    set Texte [ContenuDuFichier $Fichier]
    regsub -all "\n\"" $Texte "\"" Texte

    
    set Prems 1
    set Deuss 0
    set Trois 0
    set LesTaxId {}
    set LesTaxIdsDuG {}
    set LesEtatsDuG {}
    set LesEspecesDuG {}
    set LesClades {}
    foreach Ligne [split $Texte "\n"] {
	if {$Prems} {
	    set Prems 0
	    set Deuss 1
	    set LesBox [lrange [split $Ligne ";"] 4 end]
	    set BilanCilio2014(ListOf,Box) $LesBox
	    continue
	}
	if {$Deuss} { set Trois 1; set Deuss 0 ; continue }
	if {$Trois} { set Trois 0; set BilanCilio2014(ListOf,Categories) [lrange [split $Ligne ";"] 4 end]; continue }
	set Classe ""
	if {[regexp {;\"([^\"]+)\";} $Ligne Match Classe]} {
	    regsub  {;\"([^\"])+\";} $Ligne ";Classe;" Ligne
	}
	set LesMots [split $Ligne ";"]
	
	set TaxId  [string trim [lindex $LesMots 0] " -"]
	set Espece [string trim [lindex $LesMots 1] " -"]
	set Clade  [string trim [lindex $LesMots 2] " -"]
	set Etat   [string trim [lindex $LesMots 3] " -"]

	if {$TaxId=="" && $Espece=="" && $Clade=="" && $Etat==""} {
	    set LesAccess [lrange $LesMots 4 end]
	    set BilanCilio2014(ListOf,Access) $LesAccess
	    break
	}

	set Clade "${Etat}_$Clade"
	regsub -all " +" $Clade "_" Clade 

	if {[regexp {^[0-9]+$} $TaxId]} {
	    lappend LesTaxIdsDuG  $TaxId
	    lappend LesEspecesDuG $Espece
	    lappend LesEtatsDuG   $Etat
	    lappend LesClassesDuG $Classe
	    lappend BilanCilio2014(ListOf,TaxId) $TaxId
	    lappend BilanCilio2014(ListOf,Class) $Classe
	    set BilanCilio2014($TaxId,PA) [lrange $LesMots 4 end]
	    set BilanCilio2014($TaxId,State) $Etat
	    set BilanCilio2014($TaxId,Class) $Classe
	    set BilanCilio2014($Classe,TaxId) $TaxId
	} else {
	    set Compte $Espece
	    lappend BilanCilio2014(ListOf,Clade) $Clade 
	    set BilanCilio2014($Clade,Count)   $Compte
	    set BilanCilio2014($Clade,State)   $Etat
	    set BilanCilio2014($Clade,TaxId)   $LesTaxIdsDuG
	    set BilanCilio2014($Clade,Species) $LesEspecesDuG
	    set BilanCilio2014($Clade,States)  $LesEtatsDuG
	    set BilanCilio2014($Clade,Class)   $LesClassesDuG
	    set BilanCilio2014($Clade,TaxId)   $LesTaxIdsDuG
	    set BilanCilio2014($Clade,PA) [lrange $LesMots 4 end]
	    foreach TaxId $LesTaxIdsDuG {
		set BilanCilio2014($TaxId,Clade) $Clade
		set BilanCilio2014($TaxId,Clade) $Clade
	    }
	    set LesTaxIdsDuG {}
	    set LesEtatsDuG {}
	    set LesEspecesDuG {}
	}
    }
    foreach S [array names BilanCilio2014 "10090,*"] {
	regsub 10090 $S 9606 H
	Espionne "$S $H"
	set BilanCilio2014($H) $BilanCilio2014($S)
    }
    regsub -all 0 $BilanCilio2014(10090,PA) 1 BilanCilio2014(9606,PA)
    return [BilanCilio2014 $Qui $Quoi]
}

proc SelectClade {{Multiple ""} {UseQds ""}} {
    if {$Multiple==""} { set Multiple "One" }
    set GetAll   [string equal -nocase "GetAll"   $Multiple]
    set Multiple [string equal -nocase "Multiple" $Multiple]
    set UseQds   [string equal -nocase "UseQds"   $UseQds]
    if {[OnTraite "CilioCarta" "Like"]} {
	if {$UseQds} {
	    set LesBilCla [QuestionDeScience CilioCarta "ret BilanCilio ListOf Clade"]
	} else {
	    set LesBilCla [BilanCilio ListOf Clade]
	}
	set LesClades {}
	foreach BilCla $LesBilCla {
	    regsub {[^_]+_} $BilCla "" Clade          ;#rR on enleve Y_ N_ et PR_
	    lappend LesClades $Clade
	}
	set LesClades [lsort -unique $LesClades]
    } elseif {[OnTraite "OI2017" "Like"]} {
	if {$UseQds} {
	    set LesClades [QuestionDeScience OI "ret CMC ListOf Clade"]
	} else {
	    set LesClades [CMC ListOf Clade]
	}
	set LesClades [lsort -unique $LesClades]

    }



    if {$GetAll} { return $LesClades }

    if {$Multiple} {
	if {[OnTraite "CilioCarta"]} { return [lrange $LesClades 0 end] }
	set Choisis [Affiche [join $LesClades "\n"] "AvecRetour" "Select within this list. Highlight several and press 'Validate selection' or 'All'"]
	return [split $Choisis "\n"]
    }

    set LesClades [linsert $LesClades 0 "Use another one"]
    set Choisi [ChoixParmi $LesClades]
    if {$Choisi=="Use another one"} { set Choisi [Entre "Hominidae"] }

    return $Choisi
}

proc BilanCilioQds {{Qui ""} {Quoi ""}} {
    return [QuestionDeScience CilioCarta "ret BilanCilio $Qui $Quoi"]
}

proc CladeContent {Clade {UseQds ""} {WithoutTaxIds ""}} {
    #rR WithoutTaxIds est une liste de TaxIds qu'il faut ne pas considérer (typiquement 9606)
    #rR UseQds Pour aller plus vite ... mais attention à ne pas le faire en QDS
    if {$UseQds=="UseQds" && ( ! [OnTraite CilioCarta] || ! [PourWscope]) } {
	return [QuestionDeScience CilioCarta "ret CladeContent $Clade Direct $WithoutTaxIds"]
    }
    set WithoutTaxIds [split $WithoutTaxIds ","]
    set Content {}
    foreach S {Y PR N} {
	if {[regexp {([A-Z]+)_} $Clade Match X]} {
	    if {$S!=$X} { Espionne $Clade; continue } 
	    set C [BilanCilio $Clade "CladeContentTaxIds"]
	} else {
	    set C [BilanCilio "${S}_$Clade" "CladeContentTaxIds"]
	}
	foreach TaxId $C {
	    if {[lsearch $WithoutTaxIds $TaxId]>=0} { continue }
	    lappend Content $TaxId
	}
    }
    return $Content
}

proc BilanCilio {{Qui ""} {Quoi ""}} {
    global BilanCilio

    if {[OnTraite CilioCarta2014]} { return [BilanCilio2014 $Qui $Quoi] }

    #rR on lit le fichier Excel de Odile
    #rR gscope puts BilanCilio ListOf Usage

    if {[info exists BilanCilio($Qui,$Quoi)]} { return $BilanCilio($Qui,$Quoi) }
    if {[info exists BilanCilio("EstCharge")]} {
	regsub -all "_" $Qui   " " Qi
	regsub -all "_" $Quoi  " " Qo
	if {[info exists BilanCilio($Qui,$Qo)] } { return $BilanCilio($Qui,$Qo) }
	if {[info exists BilanCilio($Qi,$Quoi)]} { return $BilanCilio($Qi,$Quoi) }
	if {[info exists BilanCilio($Qui,Column)] && [info exists BilanCilio($BilanCilio($Qui,Column),$Quoi)]} { return $BilanCilio($BilanCilio($Qui,Column),$Quoi) }
	if {[info exists BilanCilio($Qi,Column)]  && [info exists BilanCilio($BilanCilio($Qi,Column),$Quoi)]}  { return $BilanCilio($BilanCilio($Qi,Column),$Quoi) }
	if {[info exists BilanCilio($Qui,Column)] && [info exists BilanCilio($BilanCilio($Qui,Column),$Qo)]}   { return $BilanCilio($BilanCilio($Qui,Column),$Qo) }
	if {[info exists BilanCilio($Qi,Column)]  && [info exists BilanCilio($BilanCilio($Qi,Column),$Qo)]}    { return $BilanCilio($BilanCilio($Qi,Column),$Qo) }
	if {$Qui=="Example"} {
	    set LesExemples {}
	    foreach Us $BilanCilio(ListOf,Usage) {
		if { ! [regexp "^Bilan" $Us]} { continue }
		lappend LesExemples "\n$Us"
		set Res [eval $Us]
		if {[string length $Res]>100} { set Res "[string range $Res 0 132] ..." }
		lappend LesExemples $Res
	    }
	    lappend LesExemples "\nYou can run all these commands with :"
	    lappend LesExemples "gscope puts BilanCilio N_Fungi TaxId"
	    return [join $LesExemples "\n"]
	}		
	return ""
    }
    set BilanCilio("EstCharge") 1

    #rR ************************************************** attention il faut le fichier sinon return 0 si on demande exists vide autrement
#    set Fichier "[RepertoireDuGenome]/bilan/bilanOK.csv"
    set Fichier "/genomics/link/CilioCarta/bilan/bilanOK.csv"
    if {[FileAbsent $Fichier]} {
	unset BilanCilio
	if {$Qui=="exists"} { return 0 }
	return ""
    }
    set BilanCilio(exists,) 1

    set ListOfUsage [list \
		   "gscope puts BilanCilio Usage" \
		   "gscope puts BilanCilio Example" \
		   "BilanCilio ListOf GscopeId" \
		   "BilanCilio ListOf UniprotId" \
		   "BilanCilio ListOf TaxId" \
		   "BilanCilio ListOf Class" \
		   "BilanCilio ListOf Clade" \
		   "" \
		   "BilanCilio 10090  Species" \
		   "BilanCilio 10090  Class"   \
		   "BilanCilio 10090  Clade"   \
		   "BilanCilio 10090  State"   \
		   "BilanCilio 10090  TaxId"   \
		   "" \
		   "BilanCilio (556484_12968) Column" \
		   "BilanCilio (556484_12968) Clade"  \
		   "" \
		   "BilanCilio Y_Fungi  TaxId" \
		   "BilanCilio Y_Fungi  CladeContentTaxIds" \
		   "BilanCilio Y_Fungi  CladeContentSpecies" \
		   "BilanCilio Y_Fungi  CladeContentColumns" \
		   "BilanCilio N_Fungi  Permil" \
		   "BilanCilio PR_Fungi Count" \
		   "" \
	       ]

    set BilanCilio(ListOf,Usage) $ListOfUsage
    set BilanCilio(Usage,) [join $ListOfUsage "\n"] 

    set BilanCilio(Filename,) $Fichier 

    set Texte [ContenuDuFichier $Fichier]
    regsub -all "\n\"" $Texte "\"" Texte
    
    set CladeContentTaxIds  {}
    set CladeContentSpecies {}
    set CladeContentColumns {}

    set Prems 1
    set Deuss 0
    set Trois 0
    set Quats 0
    set N 0
    foreach Ligne [split $Texte "\n"] {
	if {0 && [incr N]==1000} { break }
	if {$Prems} {
	    set Prems 0
	    set Deuss 1
	    set LesTaxIdLus [lrange [split $Ligne ";"] 5 end]
	    set Column 5
	    set CladeContentTaxIds {}
	    set LesTaxId {}
	    foreach TaxId $LesTaxIdLus {
		if {$TaxId==""} {
		    if {$CladeContentTaxIds=={}} { break }
		    set TaxId "([join $CladeContentTaxIds { }])"
		    lappend BilanCilio(ListOf,CladeTaxIds) $TaxId
		    set BilanCilio($Column,CladeContentTaxIds)   $CladeContentTaxIds
		    set BilanCilio($Column,CladeContentColumns)  $CladeContentColumns
		    set CladeContentColumns {}
		    set CladeContentTaxIds {}
		} else {
		    lappend CladeContentColumns $Column
		    lappend CladeContentTaxIds  $TaxId
		    lappend BilanCilio(ListOf,TaxId) $TaxId
		}
		set BilanCilio($TaxId,Column) $Column
		set BilanCilio($Column,TaxId) $TaxId
		incr Column
	    }
	    continue
	}
	if {$Deuss} {
	    set Trois 1
	    set Deuss 0
	    set LesEspecesLus [lrange [split $Ligne ";"] 5 end]
	    set Column 5
	    set LesEspeces {}
	    foreach Espece $LesEspecesLus {
		regsub { \(.+\) *$} $Espece "" Espece
		if {$Espece==""} { break }
		set TaxId $BilanCilio($Column,TaxId)
		if {[regexp {^[0-9]+$} $Espece]} {
		    set TailleClade $Espece
		    set BilanCilio($Column,CladeContentSize)    $TailleClade
		    set BilanCilio($Column,IsClade)             1
		    set BilanCilio($Column,CladeContentSpecies) $CladeContentSpecies
		    lappend BilanCilio(ListOf,CladeColumn)      $Column
		    set CladeContentSpecies {}
		} else {
		    lappend CladeContentSpecies              $Espece
		    lappend BilanCilio(ListOf,Species)       $Espece
		    lappend BilanCilio(ListOf,SpeciesColumn) $Column
		    set BilanCilio($Column,TaxId)            $TaxId
		    set BilanCilio($Column,Species)          $Espece
		    set BilanCilio($Espece,TaxId)            $TaxId
		    set BilanCilio($TaxId,OS)                $Espece
		    regsub -all " " $BilanCilio($TaxId,OS) "_" BilanCilio($TaxId,OS_) 
		}
		incr Column
	    }
	    continue
	}
	if {$Trois} {
	    set Trois 0
	    set Quats 1
	    #rR attention il y a des ; protégés par de "" on les remplace par 1 2 3 etc.
	    set iC 0
	    while {[regexp {;\"([^\"]+)\";} $Ligne Match Class]} {
		set ClassMemo($iC) $Class 
		regsub  {;\"([^\"])+\";} $Ligne ";$iC;" Ligne
		incr iC
	    }
	    set LesClassLus [lrange [split $Ligne ";"] 5 end]
	    set Column 5
	    set LesEspeces {}
	    foreach Class $LesClassLus {
		if {[info exists ClassMemo($Class)]} { set Class $ClassMemo($Class) }
		if {$Class==""} { break }
		set TaxId $BilanCilio($Column,TaxId)
		if {[info exists BilanCilio($Column,IsClade)]} {
		    #rR ici on a le clade seul et non pas la classe de l'espèce.
		    set CladeSeul $Class
		    set BilanCilio($Column,CladeSeul) $CladeSeul
		    #rR il faut attendre la ligne 4 pour avoir les Y PR N
		} else {
		    set BilanCilio($Column,DoCount) 1
		    set BilanCilio($Column,TaxId) $TaxId
		    set BilanCilio($Column,Class) $Class
		}
		lappend BilanCilio(ListOf,Class) $Class  ; #rR attention les clades font partie de la liste des classes
		incr Column
	    }
	    continue
	}
	if {$Quats} {
	    set Quats 0
	    set LesHeadersLus [split $Ligne ";"]
	    set Column 0
	    set LesHeaders {}
	    foreach Header $LesHeadersLus {
		if {$Column==0} { set Header "Comment" }
		regsub {\([^\(]+\)} $Header "" Header
		if {$Header==""} { break }
		set Header [string trim $Header]
		set Header [BonneEntetePourBilanCilio $Header]
		if {[regexp {^(Y|PR|N)$} $Header]} {
		    set Etat $Header
		    set TaxId $BilanCilio($Column,TaxId)
		    if {[info exists BilanCilio($Column,CladeSeul)]} {
			set CladeSeul $BilanCilio($Column,CladeSeul)
			set EtatClade      "${Etat}_$CladeSeul"
			set BilanCilio($Column,Clade)     $EtatClade
			set BilanCilio($EtatClade,Column) $Column
			set BilanCilio($TaxId,Clade)      $EtatClade
			lappend BilanCilio(ListOf,Clade)  $EtatClade
			set Header $EtatClade
		    } else {
			set Species $BilanCilio($Column,Species)
			set SpeciesEtat "${Species} $Etat"
			set BilanCilio($SpeciesEtat,Column) $Column
			set BilanCilio($SpeciesEtat,TaxId)  $TaxId
			set BilanCilio($SpeciesEtat,Class)  $BilanCilio($Column,Class)
			#set Header $SpeciesEtat
			set Header $Species
		    }
		    set BilanCilio($Column,State) $Etat
		}
		set HeaderUnderscore $Header
		regsub -all " "      $HeaderUnderscore "_" HeaderUnderscore
		regsub -all {[\(\)]} $HeaderUnderscore ""  HeaderUnderscore
		set BilanCilio($Column,Header) $HeaderUnderscore
		set BilanCilio($Header,Column) $Column
		set BilanCilio($HeaderUnderscore,Column) $Column
		lappend BilanCilio(ListOf,Header) $HeaderUnderscore
		incr Column
	    }
	    continue
	}
	#rR maintenant il faut lire les données et les affecter en fonction de la column
	set LesMots [split $Ligne ";"]
	lassign $LesMots Comment InGoldStandard GscopeId UniprotId InOrthoinspector 
	set G $GscopeId
	lappend BilanCilio(ListOf,GscopeId) $GscopeId
	foreach K {Comment InGoldStandard GscopeId UniprotId InOrthoinspector} { 
	    set BilanCilio($G,$K) [set $K] 
	}
	set L [llength $BilanCilio(ListOf,Header)]; incr L -1
	foreach H $BilanCilio(ListOf,Header) Value [lrange $LesMots 0 $L] {
	    set BilanCilio($G,$H) $Value
	}
    }
    set BilanCilio(ListOf,JoinedClade) {}
    foreach Clade $BilanCilio(ListOf,Clade) {
	regsub {^[YNPR]+_} $Clade "" JoinedClade
	lappend BilanCilio(ListOf,JoinedClade) $JoinedClade
	if { ! [info exists BilanCilio($JoinedClade,CladeContentTaxIds)]} {
	    set BilanCilio($JoinedClade,CladeContentTaxIds) {}
	    set BilanCilio($JoinedClade,CladeContentSpecies) {}
	} 
#	LConcat BilanCilio($JoinedClade,CladeContentTaxIds)  $BilanCilio($Clade,CladeContentTaxIds)
#	LConcat BilanCilio($JoinedClade,CladeContentSpecies) $BilanCilio($Clade,CladeContentSpecies)
    }
    set BilanCilio(ListOf,JoinedClade) [lsort -unique $BilanCilio(ListOf,JoinedClade)]

    foreach CladeColumn $BilanCilio(ListOf,CladeColumn) {
	foreach Column $BilanCilio($CladeColumn,CladeContentColumns) {
	    set BilanCilio($Column,CladeColumn) $CladeColumn
	    set BilanCilio($Column,Clade) $BilanCilio($CladeColumn,Clade)
	}
    }

    set NG 0
    foreach G $BilanCilio(ListOf,GscopeId) {
	incr NG
	set U $BilanCilio($G,UniprotId)
	lappend BilanCilio(ListOf,UniprotId) $U
	set Column 0
	foreach H $BilanCilio(ListOf,Header) {
	    set BilanCilio($U,$H) $BilanCilio($G,$H)
	    if {[info exists BilanCilio($Column,DoCount)] && $BilanCilio($G,$H)==1 } { incr BilanCilio($H,Count) $BilanCilio($G,$H)}
	    incr Column
	}
    }
    foreach H $BilanCilio(ListOf,Header) {
	if { ! [info exists BilanCilio($H,Count)]} { set BilanCilio($H,Count) 0 }
	set BilanCilio($H,Permil) [expr round($BilanCilio($H,Count)*1000./$NG)]
	regsub -all " " $H "_" H
	lappend BilanCilio(ListOf,Usage) "BilanCilio HSAP00001 $H"  
    }
    set BilanCilio(ListOf,UniprotId) [lsort $BilanCilio(ListOf,UniprotId)]

    if {0} {
	foreach S [array names BilanCilio "10090,*"] {
	    regsub 10090 $S 9606 H
	    Espionne "$S $H"
	    set BilanCilio($H) $BilanCilio($S)
	}
	regsub -all 0 $BilanCilio(10090,State) 1 BilanCilio(9606,State)
	set BilanCilio(9606,Species) "Homo sapiens"
	set BilanCilio(9606,TaxId)   9606
    }
    set BilanCilio(9606,Clade) $BilanCilio($BilanCilio(10090,Column),Clade)
    set BilanCilio(9606,State) "Y"
    return [BilanCilio $Qui $Quoi]
}