#rR gscope_oi.tcl

#rR 20170101 Traitement des proteomes des poissons de Audrey Defosset
#rR on reprend ici ce qui a été fait pour CilioCarta
#rR avec de nouveaux noms
#rR OiName devient ainsi OiCode
#rR Yannis a ramené les protéomes Achaea Bacteria Eukaryota et Virus
#rR Pour chaqcun j'ai créé desprotéomes bien nommé (dans NotaBene dans un premier temps)
#rR Et je leur ai donné un nouveau nom qui ICI SERA APPELE OI de OiCode
#rR C'est la procédure OiCode
#rR Pour la bactérie 'Trucmuch machin chose' ce sera BTruma et s'il y a plusieurs BTruma ce sera BTrumaA BTrumaB ... BTrumaZ BTrumaAA BTrumaAB ...

proc GyraseTfasDesCopains {} {
    #rR On lit le taxobla et si l'access est celui d'un proteome cité dans les fichiers lus par Gyrase
    #rR on va le chercher dans les proteomes de NotaBene
    set TfaCopDir "[RepertoireDuGenome]/tfasdescopainsGyrase"
    file mkdir $TfaCopDir
    foreach Nom [ListeDesPABs] {
	set FicTfaCop "$TfaCopDir/$Nom"
	if {[file exists $FicTfaCop]} { continue }
	set FicTaxobla [GscopeFile $Nom "taxobla"]
	if {[FileAbsent $FicTaxobla]} { continue }
	Espionne $Nom
	set LesSeq {}
	foreach Ligne [LesLignesDuFichier $FicTaxobla] {
	    scan $Ligne "%s %s %s" PN SCore Ox
	    if {[Gyrase $Ox YN]==""} { continue }
	    set FicTfaProteome [OiCode $Ox FullFilePath]
	    set Info [lindex [split $Ligne "\t"] 4]
	    scan $Info "%s %s" BId Ac
	    set Bank [StringApres "BANK=" dans $Info]
	    set Access "$Bank|$Ac|$BId"
	    set Seq [LaSequenceDuTFAs $FicTfaProteome $Access]
	    if {$Seq==""} { continue }
	    lappend LesSeq $Seq
	}
	SauveLesLignes $LesSeq dans $FicTfaCop
	lappend LesCrees $FicTfaCop
    }
    return $LesCrees
}

proc Gyrase {{Qui ""} {Quoi ""}} {
    global Gyrase
    set Qui  [string toupper $Qui]
    set Quoi [string toupper $Quoi]
    if {[info exists Gyrase($Qui,$Quoi)]} { return $Gyrase($Qui,$Quoi) } 
    if {[info exists Gyrase("EstCharge")]} { return "" }
    set Gyrase("EstCharge") 1
    set Gyrase(YES,FILENAME) "/genomics/link/AArcfu/DeClaudine/14"
    set Gyrase(NO,FILENAME)  "/genomics/link/AArcfu/DeClaudine/16"
    foreach YN [list NO YES] {
	foreach  Ligne [LesLignesDuFichier $Gyrase($YN,FILENAME)] {
	    set Os [string trim $Ligne]
	    set Oi [OiCode $Os OI]
	    set Ox [OiCode $Os OX]
	    lappend Gyrase($YN,LISTOFOI) $Oi
	    lappend Gyrase($YN,LISTOFOS) $Os
	    lappend Gyrase($YN,LISTOFOX) $Ox
	    lappend Gyrase(ALL,LISTOFOI) $Oi
	    lappend Gyrase(ALL,LISTOFOS) $Os
	    lappend Gyrase(ALL,LISTOFOX) $Ox
	    set OX $Ox
	    set OI [string toupper $Oi]
	    set OS [string toupper $Os]
	    set Gyrase($OI,OI) $Oi
	    set Gyrase($OI,OS) $Os
	    set Gyrase($OI,OX) $Ox
	    set Gyrase($OI,YN) $YN
	    set Gyrase($OS,OI) $Oi
	    set Gyrase($OS,OS) $Os
	    set Gyrase($OS,OX) $Ox
	    set Gyrase($OS,YN) $YN
	    set Gyrase($OX,OI) $Oi
	    set Gyrase($OX,OS) $Os
	    set Gyrase($OX,OX) $Ox
	    set Gyrase($OX,YN) $YN
	}
    }
    return [Gyrase $Qui $Quoi]
}

proc OiLikeFishProteomes {{Rep ""}} {
    ##rR on remplace 
    #>XP_018528244.1 PREDICTED: F-box only protein 15-like isoform X1 [Lates calcarifer]
    #par 
    #>XP_018528244.1 PREDICTED: F-box only protein 15-like isoform X1 OS=Lates calcarifer OX=123456
    if {$Rep==""} { set Rep "/home/defosset/These/Proteome/Purged_proteomes/Other_fish" }
    NousAllonsAuBoulot "$Rep/NotaBene"
    set LesNotaBene {}
    foreach Fic [glob "../*_purged"] {
	Espionne $Fic
	if { ! [regexp -nocase {^../([a-z]+)_([a-z]+)_purged$} $Fic Match Genre Espece]} { FaireLire "$Fic bad name" ; continue }
	set OS "${Genre} ${Espece}"
	set OX [Tax $OS]
	if {$OX==""} { FaireLire "$OS has no TaxId" }
	set LeNew {}
	foreach Access [LaSequenceDuTFAs $Fic "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $Fic $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    regsub {\[.+$} $Entete "" Entete
	    append Entete " OS=$OS OX=$OX" 
	    set New [SequenceFormatTFA $Seq $Entete "protbrut"]
	    lappend LeNew $New
	}
	set FishCode "F[string range $Genre 0 2][string range $Espece 0 1]"
	if {[info exists DejaVu($FishCode)]} { set FishCode [Entre "$FishCode deja vu"] }
	set NewName ${FishCode}_[join [split $OS " "] "_"]_$OX
	lappend LesNotaBene $NewName
	Espionne $NewName
	SauveLesLignes $LeNew dans $NewName
    }
    OnRevientDuBoulot
    return $LesNotaBene
}

proc BiggestHeaderPourTous {{Rep ""}} {
    if {$Rep==""} { set Rep "." }

    foreach Fasta [lsort [glob -nocomplain "$Rep/*"]] {
	set R [BiggestHeader $Fasta]
	scan $R "%d" M
	if {$M>600} { Espionne "$Fasta\n$R" }
    }
}

proc BiggestHeader {Fichier} {
    set Max 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase "^>" $Ligne]} { continue }
	set L [string length $Ligne]
	if {$L>$Max} {
	    set Max $L
	    set Biggest $Ligne
	}
    }
    return "$Max $Biggest"
}


proc OiProteomesDir {} {
    return "/genomics/link/OrthoInspector_Proteomes/Proteomes2016"
}

proc OiDomainFromOiCode {OiCode} {
    return [OiDomain [string index $OiCode 0] Que]
}

proc OiDomain {{Value ""} {Quoi ""}} {
    global OiDomain
    global OIDomainStack
    #rR Positionne Rend le domaine ou la dir du domaine concerné Euka Bact Arch Virus Qfo
    #rR Une lettre suffit pour les domaines pour les mots clés il en faut au moins 3
    #rR  ... mais attention il ne faut pas que les domaines commencent pas les mots clefs listés ci-dessous
    #rR OiDomain        rend le defaut (Eukaryota) ou autre s'il a été modifié précédemment
    #rR OiDomain B      positionne à Bacteria et rend  Bacteria
    #rR OiDomain B Dir  positionne à Bacteria et rend  /genomics/link/OrthoInspector_Proteomes/Bacteria
    #rR OiDomain Dir    rend  /genomics/link/OrthoInspector_Proteomes/Bacteria si c'est le dernier positionné
    #rR OiDomain Dir B  pareil que l'inverse
    #rR OiDomain Lis    rend la liste de ce qui existe
    #rR On peut mémoriser par OiDomain MemorizeThenSetTo Nouveau
    #rR   .... et dépiler par OiDomain BackToMemorized
    
    set ProteomesDir [OiProteomesDir]
    set LesInitiales {}
    set LesQueues {}
    foreach PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/*"] {
	set Queue [file tail $PossibleDir]
        if {[regexp "NewSoft" $Queue]} { continue }  ;#rR 20220207
        if {$Queue=="QFO"} { continue }              ;#rR a supprimer !!!!!!!!!!!!!!!!!!
	lappend LesQueues $Queue
	set Ini [string index $Queue 0]
	lappend LesInitiales $Ini
	set QueueDe($Ini) $Queue
    }
    if {$Value=="Ini"} { return $LesInitiales } 
    if {$Quoi=="Que"} {
	if {[info exists QueueDe($Value)]} {
	    return $QueueDe($Value)
	} else {
	    return ""
	}
    }

    if {$Value=="Ask"} {
	set PossibleDirs [lsort [glob -nocomplain -type "d" "$ProteomesDir/*"]]
	foreach PossibleDir $PossibleDirs {
	    if {[regexpo "NewSoft" $PossibleDir]} { continue } ; #rR 20220207
	    lappend LesQueue [file tail $PossibleDir]
	}
	set Choix [ChoixParmi $LesQueue]
	if {$Choix==""} { return "" }
	return [OiDomain $Choix $Quoi]
    }

    if { ! [info exists OiDomain]} {
	if {[OnTraite ArchaeaProteome Like]} {
	    set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/Archaea"] ; #rR pour enlever NewSoft
	} elseif {[OnTraite BacteriaProteome Like]} {
	    set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/B*"]
	} elseif {[OnTraite EukaryotaProteome Like]} {
	    set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/E*"]
	} elseif {[OnTraite TransverseProteome Like]} {
	    set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/T*"]
	} elseif {[OnTraite QfoProteome Like]} {
	    set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/Q*"]
	} else {
	    set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/Eukaryota"] ; #rR pour enlever NewSoft
	}
	set OiDomain [file tail $PossibleDir]
	set OIDomainStack [list $OiDomain]
    }
    if {[regexp -nocase "^Memo" $Value]} {
	lappend OiDomainStack $OiDomain
	set OiDomain $Quoi
	return $OiDomain
    }
    if {[regexp -nocase "BackTo" $Value]} {
	set OiDomain [lindex $OIDomainStack 0]
	set OIDomainStack [lrange $OIDomainStack 0 end-1]
	return $OiDomain
    }

    set VAL  [string totitle [string range $Value 0 2]]
    set Quoi [string totitle [string range $Quoi  0 2]]

    if {$VAL in [list Dir Lis Que]} {
	set W $VAL
	set VAL $Quoi
	set Quoi $W
    }
    set V [string toupper [string index $VAL 0]]

    if {$V!=""} {
	set Dir ""
	set Dom ""
	foreach PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/*"] {
	    Espionne $PossibleDir
	    set Queue [file tail $PossibleDir]
            if {[regexp "NewSoft" $Queue]} { continue }   ; #rR 20220207
            if {$Queue=="QFO"} { continue }
	    if {$V==[string toupper [string index $Queue 0]]} {
		set Dir $PossibleDir
		set OiDomain $Queue
		break
	    }
	}
    }
    if {$Quoi=="Que"} { return [lsort $LesQueues] }
    if {$Quoi=="Lis"} { return [lsort [glob -nocomplain -type "d" "$ProteomesDir/*"]] }
    if {$Quoi=="Dir"} { return "$ProteomesDir/$OiDomain" }
    return $OiDomain
}

proc OiCodeForDomain {Dom args} {
    set GoBack 0
    if {[OiDomain]!=$Dom} {
	OiDomain "MemorizeThenSetTo" $Dom
	OiCode "Reset"
	set GoBack 1
    }
    set R [OiCode {*}$args]
    if {$GoBack} {
	OiDomain "BackToMemorized"
    }
    return $R
}

proc OiCreateOrganismXml {{Domaine ""} {DefBkDate ""} {DefBkIdentifier ""} {DefBkDescription ""}} {    

    if {$Domaine==""} { set Domaine [OiDomain] }
    if {$DefBkDate        ==""} { set DefBkDate        "2016-11-17" }
    if {$DefBkIdentifier  ==""} { set DefBkIdentifier  "UniprotKB" }
    if {$DefBkDescription ==""} { set DefBkDescription "$DefBkIdentifier - $DefBkDate" }

    OiDomain "MemorizeThenSetTo" $Domaine

    set Fichier "[OiCode ProteomesDir]/OtherDB.txt"
    if {[FileExists $Fichier]} {
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    set Date ""
	    set Iden ""
	    set Desc ""
	    lassign [split $Ligne "\t"] OX Date Iden Desc
	    set OtherDB($OX,BkDate)        $Date
	    set OtherDB($OX,BkIdentifier)  $Iden
	    set OtherDB($OX,BkDescription) $Desc
	}
    }

    set LesOX [OiCode ListOf OX]
    set File "[OiCode NotaBeneDir]/organism.xml"

    set LeXml {}
    lappend LeXml "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    lappend LeXml "<orthoinspector>"

    foreach OX $LesOX {

	set BkDate        $DefBkDate
	set BkIdentifier  $DefBkIdentifier
	set BkDescription $DefBkDescription
	if {[info exists OtherDB($OX,BkDate)       ]} { set BkDate        $OtherDB($OX,BkDate) }
	if {[info exists OtherDB($OX,BkIdentifier) ]} { set BkIdentifier  $OtherDB($OX,BkIdentifier) }
	if {[info exists OtherDB($OX,BkDescription)]} { set BkDescription $OtherDB($OX,BkDescription) }
	if {$BkDescription ==""} { set BkDescription "$BkIdentifier - $BkDate" }
	
	set OS [OiCode $OX OS]
	set OI [OiCode $OX OI]
	set FullFilename [OiCode $OX FullFilename]
	set Class [TaxClass $OX "TaxId"]
	Espionne "$OX $OS $OI $FullFilename"
	scan $OS "%s %s" Genre Espece                 ; #rR c'était avant 2017/02/02 
	regsub "$Genre " $OS "" Espece                   ; #rR on garde tout
	
	lappend LeXml "  <organism>"
	lappend LeXml "    <genus>$Genre</genus>"
	lappend LeXml "    <species>$Espece</species>"
	lappend LeXml "    <identifier>$OI</identifier>"
	lappend LeXml "    <phylum>$Class</phylum>"
	lappend LeXml "    <source>"
	lappend LeXml "      <bank>"
	lappend LeXml "        <bk_date>$BkDate</bk_date>"
	lappend LeXml "        <bk_identifier>$BkIdentifier</bk_identifier>"
	lappend LeXml "        <bk_description>$BkDescription</bk_description>"
	lappend LeXml "        <bk_taxinomy>"
	lappend LeXml "          <taxid>$OX</taxid>"
	lappend LeXml "        </bk_taxinomy>"
	lappend LeXml "     </bank>"
	lappend LeXml "    </source>"
	lappend LeXml "    <fastafile>$FullFilename</fastafile>"
	lappend LeXml "  </organism>"
    }
    lappend LeXml "</orthoinspector>"
    set Xml [join $LeXml "\n"]

    OiDomain "BackToMemorized"
    set Retour  [Sauve $Xml dans $File]    
    return $Retour
}

proc CreeBlastDatabaseWithOiCode {Domaine {NomBanque ""} {FormatdbOrMakeblastdb ""}} {

    if {$FormatdbOrMakeblastdb==""} { set FormatdbOrMakeblastdb "makeblastdb" }

    set LesFasta [OiCodeForDomain $Domaine ListOf FullFilePath]
    if {$NomBanque==""} { set NomBanque "Oi$Domaine" }

    set Rep "/blast/OrthoInspector"
    file mkdir $Rep
    NousAllonsAuBoulot $Rep

    if {[file exists $NomBanque] || [file exists $NomBanque.phr]} {
	if { ! [OuiOuNon "$NomBanque already exist. Do I overwrite"]} { OnRevientDuBoulot; return "" }
    }

    set F [open $NomBanque "w"]
    foreach Fasta $LesFasta {
	set TFA [ContenuDuFichier $Fasta]
	puts $F $TFA
    }
    close $F

    if {$FormatdbOrMakeblastdb=="formatdb"} {
	exec formatdb -i $NomBanque -p T -l $NomBanque.formatdb.log -o
    } else {
	exec /biolo/blast/bin/makeblastdb -dbtype prot -in $NomBanque -out $NomBanque -hash_index -parse_seqids
    }
    OnRevientDuBoulot
    return "$Rep/$NomBanque"
}

proc OrderedClades {Clades {GetWhat ""}} {
    #rR on trie les Cladespour avoir les plus grosses situées après les plus petites contenues dans les grosses.
    if {[regexp "," $Clades]} { set Clades [split $Clades ","] } 
    set LesEmpty {}
    set LesOX {}
    foreach Clade $Clades {
	set OX [Tax $Clade TaxId]
	if {$OX==""} { lappend LesEmpty $Clade ; continue }
	set CladeOf($OX) $Clade
	lappend LesOX $OX
    }
    #rR ne sert plus ...il suffit de trier bêtement les classes
    #set LesOrderedOX [lsort -command CompareCladeAncestor $LesOX]

    foreach OX $LesOX {
	set Class [TaxClass $OX]
	lappend LesOrderedClass $Class
	set OXDeLaClass($Class) $OX
    }
    set LesOrderedClass [lsort -decreasing $LesOrderedClass]
    set LesOrderedOX {}
    foreach Class $LesOrderedClass {
	lappend LesOrderedOX $OXDeLaClass($Class)
    }

    set LesOrdered {}
    foreach OX $LesOrderedOX {
	lappend LesOrdered $CladeOf($OX)
    }
    foreach Empty $LesEmpty {
	lappend LesOrdered $Empty
    }
    if {$GetWhat=="JoinedList"} { return [join $LesOrdered ","] }
    return $LesOrdered
}

proc TestArClade {} {
    foreach Ligne [LesLignesDuFichier [GscopeFile AHalma04100 taxobla]] {
	scan $Ligne "%s %s %s" E S OX
	Espionne [format "%-30s %s OX = %s" [ArCladeOf $OX Name] [Tax $OX Name] $OX]
    }
}

proc TestArchaeaGenomesDeClaudine {} {
    foreach OS [ClaudineArchaea ListOf OS] {
	regsub -all " +" [string trim $OS] "_" OS 
	Espionne [format "%-30s %s" [ArCladeOf $OS Name] $OS]
    }
}

proc ArCladeOf {{Qui ""} {Quoi ""}} {
    global ArCladeOf

    if {$Quoi=="Clade"} { set Quoi "Name" }

    if {[regexp -nocase "taxid" $Quoi]} { set Quoi "OX" }

    if {$Quoi=="" &&    [regexp {^[0-9]+$} $Qui]} { set Quoi "OX" }
    if {$Quoi=="" &&  ! [regexp {^[0-9]+$} $Qui]} { set Quoi "Name" }

    if {[info exists ArCladeOf($Qui,Quoi)]} { return $ArCladeOf($Qui,$Quoi) }
    set OX [Tax $Qui TaxId]
    set OS [Tax $Qui Name]
    
    foreach CX [ArClade ListOf OrderedOX] CS [ArClade ListOf OrderedName] {
	if {[JeSuisTonAncetre $CX $OX]} {
	    set ArCladeOf($OX,OX) $CX
	    set ArCladeOf($OS,OX) $CX
	    set ArCladeOf($OX,Name) $CS
	    set ArCladeOf($OS,Name) $CS
	    if {[info exists ArCladeOf($OX,$Quoi)]} { return $ArCladeOf($OX,$Quoi) }
	}
    }
    return ""
}

proc CompareCladeAncestor {A B} {
    #rR je crois que ça ne sert plus .. il suffit de trier les classes.
    #rR attention il y a aussi CompareArCladeAncestor où on a déjà mémorisé
    if {$A==$B} { return 0 }
    if {[JeSuisTonAncetre $B $A]} { return -1 }
    if {[JeSuisTonAncetre $A $B]} { return  1 }
    return 0
}

proc CompareArCladeAncestor {A B} {
    #rR attention il y a aussi CompareCladeAncestor où on utilise directement JeSuisTonAncetre
    global ArClade
    ArClade
    if {$A==$B} { return 0 }
    if {[info exists ArClade($B,AncestorOf_$A)]} { return -1 }
    if {[info exists ArClade($A,AncestorOf_$B)]} { return  1 }
    return 0
}

proc ArCladeOLD {{Qui ""} {Quoi ""}} {
    global ArClade
    if {[info exists ArClade($Qui,$Quoi)]} { return $ArClade($Qui,$Quoi) }
    if {[info exists ArClade("EstCharge")]} {
	if {[info exists ArClade($Qui,OX)]} {
	    set OX $ArClade($Qui,OX)
	    if {[info exists ArClade($OX,$Quoi)]} { return $ArClade($OX,$Quoi) }
	}
	return ""
    }
    set ArClade("EstCharge") 1
    
    set Fichier "/home/ripp/vrac/ArClade.txt"
    set ArClade(Filename,) $Fichier
    
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Name [string trim $Ligne " \t"]
	if {$Name==""} { continue }
	regsub -all " " $Name "_" Name
	set OX [Tax $Name TaxId]
	if {$OX==""} {
	    #FaireLire "$Name has no TaxId. I'll use Archaea instead"
	    set Name "Archaea"
	    set OX [Tax $Name TaxId]
	}
	set ArClade($Name,Name) $Name
	set ArClade($OX,OX)     $OX
	set ArClade($Name,OX)   $OX
	set ArClade($OX,Name)   $Name
	lappend ArClade(ListOf,OX)   $OX
	lappend ArClade(ListOf,Name) $Name
    }
    set ArClade(ListOf,OX)   [lsort -unique $ArClade(ListOf,OX)]
    set ArClade(ListOf,Name) [lsort -unique $ArClade(ListOf,Name)]
    foreach A $ArClade(ListOf,OX) {
	foreach B $ArClade(ListOf,OX) {
	    if {$A==$B} { continue }
	    if {[JeSuisTonAncetre $A $B]} { set ArClade($A,AncestorOf_$B) 1 }
	}
    }
    
    set ArClade(ListOf,OrderedOX) [lsort -command CompareArCladeAncestor $ArClade(ListOf,OX)]
    foreach OX $ArClade(ListOf,OrderedOX) {
	lappend ArClade(ListOf,OrderedName) $ArClade($OX,Name)
    }
    #parray ArClade 

    foreach D [list Bacteria Eukaryota Virus] {
	set N [Tax $D Name]
	if {$N=="root"} { set N "Other" }
	lappend ArClade(ListOf,OrderedOX)   $D
	lappend ArClade(ListOf,OrderedName) $N
    }

    return [ArClade $Qui $Quoi] 
}

proc ArClade {{Qui ""} {Quoi ""}} {
    global ArClade
    if {[info exists ArClade($Qui,$Quoi)]} { return $ArClade($Qui,$Quoi) }
    if {[info exists ArClade("EstCharge")]} {
	if {[info exists ArClade($Qui,OX)]} {
	    set OX $ArClade($Qui,OX)
	    if {[info exists ArClade($OX,$Quoi)]} { return $ArClade($OX,$Quoi) }
	}
	return ""
    }
    set ArClade("EstCharge") 1
    
    set LesClades [LesLignesDuFichier "/genomics/link/OI/fiches/PhylAr_ListOf_PhyOS.txt"]
    set LesClades [OrderedClades $LesClades]

    foreach Name $LesClades {
	set OX [Tax $Name TaxId]
	if {$OX==""} {
	    #FaireLire "$Name has no TaxId. I'll use Archaea instead"
	    set Name "Archaea"
	    set OX [Tax $Name TaxId]
	}
	set ArClade($Name,Name) $Name
	set ArClade($OX,OX)     $OX
	set ArClade($Name,OX)   $OX
	set ArClade($OX,Name)   $Name
	lappend ArClade(ListOf,OX)   $OX
	lappend ArClade(ListOf,Name) $Name
    }
    
    set ArClade(ListOf,AllOX)   $ArClade(ListOf,OX)
    set ArClade(ListOf,AllName) $ArClade(ListOf,Name)
    foreach Name [list Bacteria Eukaryota Viruses] {
	set OX   [Tax $Name TaxId]
	if {$Name=="root"} { set Name "Other" }
	lappend ArClade(ListOf,AllOX)   $OX
	lappend ArClade(ListOf,AllName) $Name
    }

    return [ArClade $Qui $Quoi] 
}

proc ArchaeaGenomesDeClaudine {{GetWhat ""}} {
    OiDomain A

    foreach OS [OiCode ListOf OS] {
	scan $OS "%s %s" Ge Es
	set GeEs "$Ge$Es"
	set OX [OiCode $OS OX]
#Espionne "$OX $GeEs \t\t$OS"
	lappend LesOXde($GeEs) $OX
    }

    set LesGS {}
    set Rates 0
    set LesMemes {}
    set LesCommeSoeur {}
    set LesRates {}
    set LesClaudine {}
    set NbAvecSoeur 0
    foreach G [ClaudineArchaea ListOf G] {
	set GX [ClaudineArchaea $G OX]
	set GS [ClaudineArchaea $G "Organism_Name"]
	set OS [OiCode $GX OS]
	set Clade [ArCladeOf $GX Name]
	lappend LesClaudine [format "%s %9d %-50s %s %s %s" $G $GX $GS Clade = $Clade]
	if {$OS!=""} {
	    set Meme($GX) 1
	    lappend LesMemes [format "%-9s %9d %-50s %-80s %s" $G $GX $GS $OS Clade = $Clade]
	    continue
	}
	set LesParents [list $GX]
	set PX $GX
	while {$OS==""} {
	    set PX [Tax $PX Parent]
	    if {$PX=="" || $PX==1} { break } 
	    lappend LesParents $PX
	    set OS [OiCode $PX OS]
	    if {$OS!=""} {  Espionne "$LesParents $OS" }
	}
	set LesSoeurs {}
	set PX [Tax $GX Parent]
	if {$PX!="" && $PX!=1} {
	    foreach OXSoeur [Tax $PX Children] {
		set OS [OiCode $OXSoeur OS]
		if {$OS!=""} {
		    lappend LesSoeurs "$OS OX = $OXSoeur"
		    set YaSoeur($OXSoeur) 1
		}
	    }
	    if {$LesSoeurs!={}} {
		incr NbAvecSoeur
		lappend LesCommeSoeur ""
		lappend LesCommeSoeur "$G $GX $Clade"
		lappend LesCommeSoeur $GS
		foreach Soeur $LesSoeurs {
		    lappend LesCommeSoeur $Soeur
		}
	    }
	    if {$LesSoeurs!={}} { continue }
	}
	lappend LesRates [format "%9s %9d %-40s %s %s %s" $G $GX $GS Clade = $Clade]
    }

    foreach OX [OiCode ListOf OX] {
	if {[info exists Meme($OX)]} {
	    lappend LesMemeQueYannis $OX
	    continue
	}
	lappend LesNouveauxDeYannis "$OX [OiCode $OX OS]"
    }

    set LesNouveauxDeYannis [lsort -index 1 $LesNouveauxDeYannis]

#    return [AfficheListe $LesClaudine   "" "Ceux de Claudine"]

    Espionne "[llength $LesClaudine] de Claudine"
    Espionne "[llength $LesMemes] Memes"
    Espionne "$NbAvecSoeur AvecSoeur"
    Espionne "[llength $LesRates] Rates"
    
    Espionne "[llength [OiCode ListOf OX]] de Yannis"
    Espionne "[llength $LesNouveauxDeYannis] Nouveaux chez Yannis"
    set LesFenetres {}
    lappend LesFenetres [AfficheListe $LesClaudine   "" "Ceux de Claudine"]
    lappend LesFenetres [AfficheListe $LesMemes      "" "LesMemes"]
#    lappend LesFenetres [AfficheListe $LesCommeSoeur "" "LesSoeurs"]
    lappend LesFenetres [AfficheListe $LesRates      "" "LesRates"] 
    lappend LesFenetres [AfficheListe $LesNouveauxDeYannis  "" "LesNouveauxDeYannis"] 
    lappend LesFenetres [AfficheListe [OiCode ListOf Info] "" "Ceux de Yannis"]

    return $LesFenetres
}

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

    set Fichier "/home/ripp/vrac/ClaudineArchaea.csv"
    LoadTxl $Fichier CA 0 ";" "" "WholeLine"

    set LesG {}
    set LesOX {}
    set LesOS {}
    foreach I $CA(ListOf,Index) {
	if { ! [regexp "^Go" $I]} { continue }
	lappend LesG $I
	set OX [GoldArchaea $I OX]
	set CA($I,OX) $OX
	if {$OX!=""} {
	    lappend LesOX $OX
	    lappend LesOS [Tax $OX Name]
	} 
    }
    set CA(ListOf,G) $LesG
    set CA(ListOf,OX) $LesOX
    set CA(ListOf,OS) $LesOS
    return [ClaudineArchaea $Qui $Quoi]
}

proc GoldArchaea {{Qui ""} {Quoi ""}} {
    global GoldArchaea
    if {[info exists GoldArchaea($Qui,$Quoi)]} { return $GoldArchaea($Qui,$Quoi) }
    if {[info exists GoldArchaea($Qui,Go)]} {
	set Go $GoldArchaea($Qui,Go)
	if {[info exists GoldArchaea($Go,$Quoi)]} { return $GoldArchaea($Go,$Quoi) }
    }
    if {[info exists GoldArchaea("EstCharge")]} { return "" }
    set GoldArchaea("EstCharge") 1
    
    set Fichier "/home/ripp/gscope/archaeaTax.txt"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	lassign [split $Ligne "\t"] Go OS Dom OX Date
	set Go [string trim $Go]
	set OS [string trim $OS]
	set OX [string trim $OX]
	set Dom [string trim $Dom]
	set Date [string trim $Date]
	set GoldArchaea($Go,Go) $Go
	set GoldArchaea($Go,OS) $OS
	set GoldArchaea($Go,OX) $OX
	set GoldArchaea($Go,Dom) $Dom
	set GoldArchaea($Go,Date) $Date
	lappend GoldArchaea(ListOf,Go) $Go
	lappend GoldArchaea(ListOf,OS) $OS
	lappend GoldArchaea(ListOf,OX) $OX
	set GoldArchaea($OS,Go) $Go
	set GoldArchaea($OX,Go) $Go
    }
    return [GoldArchaea $Qui $Quoi]
}

proc OiCodeDoublons {} {
    set LesE [OiCodeForDomain E ListOf OI]
    set LesA [OiCodeForDomain A ListOf OI]
    set LesAE [ListsIntersection $LesA $LesE]
    Espionne "[llength $LesA] [llength $LesE] [llength $LesAE]"
    EspionneL $LesAE
}

proc GeEsFrom {OS} {
    #rR Normalement on prend Hom sa 
    #rR Mais traitement spécial pour les bactéries qui commencent pas Bac (comme Bacteri Bacill ...)

    if {[string index [OiDomain] 0]=="B" && [string range [string totitle $OS] 0 2]=="Bac"} {
	set Ge "B"
	set FinOS [string range $OS [string first " " $OS] end]
	regsub -all " " $FinOS "" FinOS
	regsub -all -nocase {[^a-z0-9]} $FinOS ""  FinOS
	regsub -all {[0-9]} $FinOS "d" FinOS
	append FinOS "xxxxxx"
	set Es [string range $FinOS 0 3]
    } else {
	scan $OS "%s %s" Ge Es
	set Ge [string range $Ge 0 2]
	set Es [string range $Es 0 1]
    }
    set GeEs [string totitle "$Ge$Es"]
    regsub -all {[0-9]} $GeEs "d" GeEs

    return $GeEs
}

proc OiCodes {LesQui {Quoi ""} {LesDomaines ""}} {
    global OiCodes 

    if {[regexp {[ \t\,\;\n\r]+} $LesQui]} { set LesQui [LesMotsDuTexte $LesQui]}

    #rR il se peut qu'on ait dèjaà tout mémorisé
    set ToutDejaVu 1
    set LaReponse {}
    foreach Qui $LesQui {
	if { ! [info exists OiCodes($Qui,$Quoi)]} { set ToutDejaVu 0 ; break }
	lappend LaReponse "$Qui=$OiCodes($Qui,$Quoi)"
    }
    if {$ToutDejaVu} { return [join $LaReponse "\n"] }
 


    if {$LesDomaines==""} {
	#rR 20220207 set LesDomaines [list Archaea Bacteria Eukaryota Transverse]
	set LesDomaines [list Archaea Bacteria Eukaryota]
    } else {
	set LesDomaines [LesMotsDuTexte $LesDomaines]
    }

    foreach Domaine $LesDomaines {
	#OiDomain "MemorizeThenSetTo" $Domaine
	set ToutTrouve 1
	set DomaineCourant $Domaine
	foreach Qui $LesQui {
	    Espionne "$Domaine $Qui OiCode $Qui $Quoi"
	    if {[info exists QuoiDe($Qui)] && $QuoiDe($Qui)!=""} { continue }
	    Espionne "             $Domaine $Qui $Quoi"
	    set Q [OiCodeForDomain $Domaine $Qui $Quoi]
	    if {$Q!=""} {
		set QuoiDe($Qui) $Q
	    } else {
		foreach DomainePossible $LesDomaines {
		    #rR on essaie d'abord les autres domaines et on y reste si on trouve
		    if {$DomainePossible==$DomaineCourant} { continue }
		    Espionne "************* $DomainePossible $Qui $Quoi"
		    set QQ [OiCodeForDomain $DomainePossible $Qui $Quoi]
		    if {$QQ!=""} {
			set Domaine $DomainePossible
			set QuoiDe($Qui) $QQ
			continue
		    }
		}
		set ToutTrouve 0
	    }
	    #Espionne "$Qui =$QuoiDe($Qui)="
	}
	if {$ToutTrouve} { break }
	#OiDomain "BackToMemorized"
    }

    set LesQuiQuoi {}
    foreach Qui $LesQui {
	set R ""
	if {[info exists QuoiDe($Qui)]} { set R $QuoiDe($Qui) }
	lappend LesQuiQuoi "$Qui=$R"
	set OiCodes($Qui,$Quoi) $R
    }
    set QuiQuoi [join $LesQuiQuoi "\n"]

    return $QuiQuoi
} 

proc OiCode {{Qui ""} {Quoi ""}} {
    global OiCode
    JeMeSignale
    #rR OX est le TaxId, OS le vrai nom de l'organisme, OI le petit nom, OW l'organisme bien écrit 
    #rR On définit ici comment doit s'appeler un organisme son OiCode par exemple EHomsa pour Homo sapiens
    #rR On nomme les fichiers OI_OW_OX  et on rajoute pour chaque entête OI=EHomsa OX=9606
    #rR Ces fichiers sont rangés dans le sous-répertoire NotaBene (les bien nommés ! ;) )
    #rR OW est en fait le OS en remplaçant les caractères louches par _
    #rR Attention Si on veut remplacer NotaBene par autre chose il faut le faire partout ...
    #rR OiCode tient compte de OiDomain : Archaea Bacteria Eukaryota etc.

    if {[regexp -nocase "PreFixe" $Quoi]} { set Quoi "OI" }

    if {$Qui=="Reset"} {
	if {[info exists OiCode]} { unset OiCode }
	return ""
    }

    if {[info exists OiCode($Qui,$Quoi)]} { return $OiCode($Qui,$Quoi) }
    if {[info exists OiCode("EstCharge")]} {
	if {[info exists OiCode($Qui,OX)]} {
	    set OX $OiCode($Qui,OX)
	    if {[info exists OiCode($OX,$Quoi)]} { return $OiCode($OX,$Quoi) }
	}
	if {$Qui=="ListOf" && $Quoi=="OXOS"} {
	    set LesOXOS {}
	    foreach OX $OiCode(ListOf,OX) {
		lappend LesOXOS "$OX $OiCode($OX,OS)"
	    }
	    return $LesOXOS
	}
	return ""
    }
    set OiCode("EstCharge") 1

    set OiFromFullFilename 0 ; #rR 0 on va le chercher dans la première ligne. 1 c'est le premier Homsa_
    set OsFromFullFilename 0 ; #rR 0 on va le chercher dans la première ligne. 1 c'est le premier entre les deux autres
    set OxFromFullFilename 0 ; #rR 0 on va le chercher dans la première ligne. 1 c'est le dernier _9606

    set ProteomesDir [OiDomain Dir]
    set NotaBeneDir "$ProteomesDir/NotaBene"
    set OiCode(ProteomesDir,) $ProteomesDir
    set OiCode(NotaBeneDir,)  $NotaBeneDir
#    set Alphabet " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    set Alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    NousAllonsAuBoulot $ProteomesDir
    Espionne $ProteomesDir
    file mkdir NotaBene

    set FichierBlackList "BlackList.txt"
    if {[file exists $FichierBlackList]} {
	foreach Ligne [LesLignesDuFichier $FichierBlackList] {
	    if {[regexp "#" $Ligne]} { continue }
	    scan $Ligne "%d" OX
	    lappend OiCode(ListOf,BlackListed) $OX
	    set OiCode($OX,IsBlackListed) 1
	}
	set OiCode(ListOf,BlackListed) [lsort -unique -integer $OiCode(ListOf,BlackListed)]
    }

    set OiCode(ListOf,Filename) {}

    #rR attention il y a deux manières de procéder ... 
    #rR juste ci dessous on a déjà traité une partie et créé les fichiers OI_OW_OX 
    foreach Fichier [lsort [glob -nocomplain "NotaBene/*"]] {
	set Queue [file tail $Fichier]
	set OI "" ; if {$OiFromFullFilename && ! [regexp -nocase {^([a-z]+)_}               $Queue Match OI      ]} { continue }
	set OW "" ; if {                       ! [regexp -nocase {^([a-z]+)_(.+)_([0-9]+)$} $Queue Match debut OW]} { continue } ; #rR On le prend toujours là 
	set OX "" ; if {$OxFromFullFilename && ! [regexp -nocase {_([0-9]+)$}               $Queue Match OX      ]} { continue }

	set OS "" ; if {$OsFromFullFilename} { set OS $OW ; regsub -all "_" $OS " " OS } ; #rR Attention c'est pas vraiment le OS d'origine  ... 

	set Ligne [PremiereLigneDuFichier $Fichier]
	regsub -all " = " $Ligne " " Ligne
	if {$OI=="" && ! [regexp {OI=([^=]+)( [A-Z][A-Z]=|$)} $Ligne Match OI]} { FaireLire "merde $Ligne"; continue }
	if {$OS=="" && ! [regexp {OS=([^=]+)( [A-Z][A-Z]=|$)} $Ligne Match OS]} { FaireLire "merde $Ligne"; continue }
	if {$OX=="" && ! [regexp {OX=([^=]+)( [A-Z][A-Z]=|$)} $Ligne Match OX]} { FaireLire "merde $Ligne"; continue }

	regsub -all {[\[\]']} $OS "" OS

	set OiCode($OX,OI) $OI
	set OiCode($OX,OS) $OS

	set GeEs [GeEsFrom $OS]
	set OiCode($OX,GeEs) $GeEs

	if { ! [info exists NbCops($GeEs)]} { set NbCops($GeEs) 0 } 
	set Info [format "%-8s %9d %s" $OI $OX $OS]
	lappend LesGeEs $GeEs
	lappend LesOX   $OX
	lappend LesOS   $OS
	incr NbCops($GeEs)
	set Filename $OS
	regsub -nocase -all {[^a-z0-9\-_]+} $Filename "_" Filename
	set OWcalcule [string trim $Filename "_"]
	if {$OW!=$OWcalcule && [OuiOuNon "from $Fichier\n$OWcalcule is not $OW\nDo I use $OWcalcule"]} { set OW $OWcalcule }
	set OiCode($OX,OW) $OW
	set OiCode($OW,OX) $OX
	set OiCode($OX,Info) $Info
	set OiCode($Info,OX) $OX

	set FullFilename "${OI}_${OW}_${OX}"
	set OiCode($FullFilename,OX) $OX
	set OiCode($OX,FullFilename) $FullFilename
	lappend OiCode(ListOfAll,FullFilename) $FullFilename 

	set FullFilePath "$NotaBeneDir/$FullFilename"
	set OiCode($FullFilePath,OX) $OX
	set OiCode($OX,FullFilePath) $FullFilePath
	lappend OiCode(ListOfAll,FullFilePath) $FullFilePath 
    }
    foreach Fichier [lsort [glob -nocomplain *.fasta]] {
	if { ! [regexp {^UP[^_]+_([0-9]+).fasta$} $Fichier Match OX]} {
	    if { ! [regexp {_([0-9]+).fasta$} $Fichier Match OX]} {
		if { ! [regexp {_new_([0-9]+).fasta$} $Fichier]} { FaireLire "Je ne sais pas quoi faire de $Fichier" }
		continue
	    }
	    if {[info exists OiCode($OX,FullFilename)]} { continue }

	    set FichierNouveau $Fichier
	    regsub {.fasta$} $FichierNouveau "" FichierNouveau
	    append FichierNouveau "_new.fasta"
	    set OX [ConvertFastaToUniprotStandard $Fichier $FichierNouveau]
	    if {$OX==""} { continue }
	    if { ! [regexp {^([0-9]+) is already converted} $OX Match OX]} {
		set Original "${Fichier}_Original"
		if {[FileAbsent $Original]} { file rename $Fichier $Original }
		regsub {_[0-9]+_new.fasta$} $FichierNouveau "_new_$OX.fasta" FichierNouveauNouveau
		if {[file exists $FichierNouveauNouveau]} { file delete $FichierNouveauNouveau }
		file rename $FichierNouveau $FichierNouveauNouveau
		set Fichier $FichierNouveauNouveau
	    }
	}
	if {[info exists OiCode($OX,FullFilename)]} { continue }
	#FaireLire "Tiens ! Un nouveau \n$Fichier\nMerci de vérifier le programme !!!!!!!!!!!!!!!" 
	#rR là on traite des nouveaux ...
	#rR on le fera en bas avec la ListOf Filename
	set Ligne [PremiereLigneDuFichier $Fichier]
	regsub -all " = " $Ligne " " Ligne
	if { ! [regexp {OS=([^=]+) [A-Z][A-Z]=} $Ligne Match OS]} { FaireLire "ca merde $Ligne"; continue }
	regsub -all {[\[\]']} $OS "" OS

	set GeEs [GeEsFrom $OS]

	set DomaineConnu 0
	if {[string index [OiDomain] 0]=="A"} { set GeEs "A$GeEs" ; set DomaineConnu 1 }
	if {[string index [OiDomain] 0]=="B"} { set GeEs "B$GeEs" ; set DomaineConnu 1 }
	if {[string index [OiDomain] 0]=="E"} { set GeEs "E$GeEs" ; set DomaineConnu 1 }
	if {[string index [OiDomain] 0]=="V"} { set GeEs "V$GeEs" ; set DomaineConnu 1 }
	if {[string index [OiDomain] 0]=="Q"} { set GeEs "Q$GeEs" ; set DomaineConnu 1 }
	if { ! $DomaineConnu                } { set GeEs "X$GeEs" }
	if { ! [info exists NbCops($GeEs)]} { set NbCops($GeEs) 0 } 
	set Info [format "%-8s %9d %s" $GeEs $OX $OS]
	set OiCode($OX,Info) $Info ; #rR il changera peut-être si deux ont le même GeEs
	lappend LesGeEs $GeEs
	lappend LesOX   $OX
	lappend LesOrga $OS
	incr NbCops($GeEs)
	set Filename $OS
	regsub -nocase -all {[^a-z0-9\-_]+} $Filename "_" Filename

	set OWcalcule [string trim $Filename "_"]
	set OiCode($OX,OW) $OWcalcule
	set Filename "${OWcalcule}_${OX}"        ; #rR attention ici on ne connait pas encore OI
	set OiCode($OX,Filename) $Filename
	lappend OiCode(ListOf,Filename) $Filename 
	set OiCode($OX,Origine) $Fichier
	set OiCode($OX,OS) $OS
    }

    foreach GeEs $LesGeEs OX $LesOX {
	lappend OiCode(ListOf,GeEs) $GeEs
	set OI ""
	set Info $OiCode($OX,Info)
	if {! [info exists OiCode($OX,OI)]} {
	    set OI $GeEs
	    if {$NbCops($GeEs)==1} {
		set OiCode($GeEs,NbCops) 1
	    } else {
		if { ! [info exists OiCode($GeEs,NbCops)]} { set OiCode($GeEs,NbCops) 0 }
		incr OiCode($GeEs,NbCops)
		set N [expr $OiCode($GeEs,NbCops) - 1]
		if {$NbCops($GeEs)<=26} {
		    set Car [string index $Alphabet $N]
		} else {
		    set D [expr $N/26]
		    set U [expr $N%26]
		    set Car "[string index $Alphabet $D][string index $Alphabet $U]"
		}
		append OI $Car
	    }
	    set OiCode($OX,OI) $OI
	    set Info [format "%-8s %9d %s" $OI $OX $OS]
	}
	set OW $OiCode($OX,OW)
	set OS $OiCode($OX,OS)
	set OI $OiCode($OX,OI)
	set OiCode($OX,Info) $Info
	set OiCode($Info,OX) $OX
	lappend OiCode($GeEs,ListOfOX) $OX
	lappend OiCode($GeEs,ListOfOI) $OI
	lappend OiCode($GeEs,ListOfOS) $OS
	lappend OiCode($GeEs,ListOfInfo) $Info

	set OiCode($OX,OX)    $OX
	if {[info exists OiCode($OX,FullFilename)]} { set OiCode($OX,Fasta) "$ProteomesDir/$OiCode($OX,FullFilename)" }

	set OiCode($OI,OX)    $OX
	set OiCode($OS,OX)    $OX
	lappend LesOS $OS
	lappend LesOW $OW
	lappend LesOI $OI
    }
    set LesOX [lsort -integer $LesOX]
    set LesOS [lsort -unique  $LesOS]
    set LesOW [lsort -unique  $LesOW]
    set LesOI [lsort -unique  $LesOI]

    foreach OI $LesOI {
	set OX $OiCode($OI,OX)
	lappend LesInfo $OiCode($OX,Info)
    }

    if {1} {
	foreach Filename $OiCode(ListOf,Filename) {
	    #if { ! [OuiOuNonMemo "Do I add OI and OX to this new fasta file"]} { Espionne "Skip $Filename" ; continue }
	    if { ! [regexp {_([0-9]+)$} $Filename Match OX]} { continue }
	    if { ! [info exists OiCode($OX,OI)]} { FaireLire "Merde $Filename" }
	    set OI $OiCode($OX,OI)
	    
	    set FullFilename "${OI}_$Filename"
	    set FastaFile "NotaBene/$FullFilename"
	    set OW ""
	    if { ! [regexp -nocase {^([a-z]+)_(.+)_([0-9]+)$} $FullFilename Match debut OW]} {
		FaireLire "$FastaFile has no correct format"
		continue
	    }
	    set OiCode($OW,OX) $OX
	    set OS [Tax $OX Name]
	    regsub -all "'" $OS "" OS
	    set OiCode($OS,OX) $OX
	    set Info [format "%-8s %9d %s" $OI $OX $OS]
	    set OiCode($OW,OX) $OX
	    set OiCode($Info,OX) $OX
	    if {[FileAbsent $FastaFile]} {
		set Origine $OiCode($OX,Origine)
		set Nouveau [RajouteEnFinDeEnteteFasta $Origine " OI=$OI OX=$OX" $FastaFile]
	    }
	    set FullFilename "$FastaFile"
	    set OiCode($OX,FullFilename) $FullFilename
	    set OiCode($FullFilename,OX) $OX
	    lappend OiCode(ListOf,FullFilename) $FullFilename  
	    set FullFilePath "$ProteomesDir/$FastaFile"
	    set OiCode($OX,FullFilePath) $FullFilePath
	    set OiCode($FullFilePath,OX) $OX
	    lappend OiCode(ListOf,FullFilePath) $FullFilePath  
	    Espionne $FullFilePath
	}
    }


    set OiCode(ListOfAll,OX)   $LesOX
    set OiCode(ListOfAll,OI)   $LesOI
    set OiCode(ListOfAll,OS)   $LesOS
    set OiCode(ListOfAll,OW)   $LesOW
    set OiCode(ListOfAll,Info) $LesInfo

    foreach K [list OX OI OS OW Info FullFilePath FullFilename] {
	set OiCode(ListOf,$K) {}
	if { ! [info exists OiCode(ListOfAll,$K)]} { Espionne "OiCode(ListOfAll,$K) does not exist"; continue } 
	foreach V $OiCode(ListOfAll,$K) {
	    if {! [info exists OiCode($V,OX)]} {
		#Espionne $OX
		#Espionne $K
		#Espionne $V
		continue
	    }
	    set OX $OiCode($V,OX)
	    if {[info exists OiCode($OX,IsBlackListed)]} { continue }
	    lappend OiCode(ListOf,$K) $V
	}
    }
    OnRevientDuBoulot
    return [OiCode $Qui $Quoi]
}

proc OiProteomeSize {Qui} {
    global OiProteomeSize
    if {[info exists OiProteomeSize($Qui)]} { return $OiProteomeSize($Qui) }
    if {[info exists OiProteomeSize("EstCharge")]} { return "" }
    set OiProteomeSize("EstCharge") 1
    
    set FichierMemo "[OiCode NotaBeneDir]/proteomesize_memo.txt"
    if {[file exists $FichierMemo]} {
	array set OiProteomeSize [ContenuDuFichier $FichierMemo]
	return [OiProteomeSize $Qui]
    }

    foreach OX [OiCode ListOf OX] {
	set OI [OiCode $OX OI]
	set Path [OiCode $OX FullFilePath]
	if {[FileAbsent $Path]} { continue }
	set L [exec sh -c "grep '^>' $Path | wc -l"]
	set OiProteomeSize($OX) $L
	set OiProteomeSize($OI) $L
	set All "$L $OX $OI"
	lappend OiProteomeSize(All) $All
    }
    Sauve [array get OiProteomeSize] dans $FichierMemo
    return [OiProteomeSize $Qui]
}



proc ConvertFastaToUniprotStandard {Fichier NewFichier} {
    if { ! [regexp {^.+_([0-9]+).fasta$} $Fichier Match OX]} { return "" }
    set OS [Tax $OX Name]
    if {$OS==""} { return "" }

    if {[regexp "_new_$OX.fasta" $Fichier] && [regexp {OR=} [PremiereLigneDuFichier $Fichier]]} {
	Espionne "$Fichier is already converted"
	return "$OX is already converted"
    }

    set LeNew {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp "^>" $Ligne]} { lappend LeNew $Ligne ; continue }
	scan $Ligne "%s" Access
	regsub -all ">" $Access "" Access
	set Gene "" ; regexp { gene=([^ ]+) }            $Ligne Match Gene
	set Tran "" ; regexp { transcript=([^ ]+) }      $Ligne Match Tran
	set Prod "" ; regexp { gene_product=([^\|]+) \|} $Ligne Match Prod
	#if {$Gene!=""} { set Access "$Gene" }
	if {$Tran!=""} { set Access "$Tran" }
	set Origine $Ligne
	regsub -all ">"  $Origine ""  Origine
	regsub -all "="  $Origine ":" Origine
	regsub -all {\|} $Origine ""  Origine
	regsub -all { +} $Origine " " Origine
	set Origine [string trim $Origine]

	set TexteProd ""
	if { 0 && $Prod!=""} { set TexteProd " $Prod" }         ; #rR attention on ne met plus Prod

	set TexteGN ""
	if {$Gene!=""} { set TexteGN " GN=$Gene" }
	set Entete ">${Access}_$OX OS=$OS$TexteGN OR=$Origine"
	lappend LeNew $Entete
    }
    SauveLesLignes $LeNew dans $NewFichier
    return $OX
}

proc RefaireLesProteomesNonUniprotStandard {{Domaine ""}} {
    
    if {$Domaine==""} { set Domaine [OiDomain] }

    NousAllonsAuBoulot "/genomics/link/OrthoInspector_Proteomes/$Domaine"
    foreach Fichier [lsort [glob -nocomplain "*fasta_Original"]] {
	Espionne 
	Espionne $Fichier
	set OX ""
	if { ! [regexp {_([0-9]+)\.fasta_Original$} $Fichier Match OX]} { continue }
	Espionne $OX
	foreach NewCree [glob -nocomplain "*_new_$OX.fasta"] {
	    Espionne $NewCree
	    file delete $NewCree
	}
	foreach NB [glob -nocomplain "NotaBene/*_$OX"] {
	    Espionne $NB
	    file delete $NB
	}
	set FastaAConvertir ""
	regsub {_Original$} $Fichier "" FastaAConvertir
	file copy -force $Fichier $FastaAConvertir
    }
    OnRevientDuBoulot
}