#fS gscope_olymclade.tcl les OLYMpiades pour les CLADEs
#rR on y fait concourir des clades pour savoir comment ils se comportent dans les blast

proc LesBacteriesDeClaudine {{GetWhat ""}} {
    set Groupe1 {
        "Mycobacterium tuberculosis H37Rv"
        "Helicobacter pylori g27"
        "Deinococcus radiodurans r1"
        "Treponema pallidum ss14"
    }
    set Groupe2 {
        "Escherichia coli atcc8739"
        "Staphylococcus aureus mu50"
        "Streptococcus pneumoniae R6"
        "Thermus thermophilus hb27"
        "Mycoplasma genitalium G-37"
    }
    set LesBons {}
    foreach Clau [concat $Groupe1 $Groupe2] {
        scan $Clau "%s %s %s" G E S
        Espionne
        Espionne $Clau
        set LesPossibles [glob -nocomplain "/genomics/link/OrthoInspector_Proteomes/Bacteria/NotaBene/*${G}_${E}*"]
        if {[llength $LesPossibles]!=1} {
            set LesMeilleurs [glob -nocomplain "/genomics/link/OrthoInspector_Proteomes/Bacteria/NotaBene/*${G}_${E}*${S}*"]
            if {[llength $LesMeilleurs]==1} {
                set LesPossibles $LesMeilleurs
            }
        }
        if {[llength $LesPossibles]!=1} {
            Espionne "***************************************************** lequel je prends parmi les suivants ?"
            foreach Possible $LesPossibles {
                Espionne [file tail $Possible]
            }
        } else {
            Espionne [file tail [lindex $LesPossibles 0]]
        }
        lappend LesBons [lindex $LesPossibles 0]
    }
    foreach Bon $LesBons {
        set N [regexp -all ">" [ContenuDuFichier $Bon]]
        set Queue [file tail $Bon]
        regsub -all "_" $Queue " " Queue
        lappend LesQueues $Queue
        scan $Queue "%s" OI
        Espionne $OI $N
    }
    if {$GetWhat=="GetFiles"} { return $LesBons }
    
    return $LesQueues
}

proc JoyFungi {{FileToCreate ""}} {
    #rR Parmi tous les fungi on veut mettre les JoyOXOS en début puis les autres
    #rR Ceci pour créer un Paraph (Paraphylum) voir plus bas la proc.
    #rR On teste d'abord le OX .. fastoce ... mais si on ne le trouve pas on teste l'OS 
    #rR et par chance il se trouve que les OS des Joy non trouvés n'ont que 2 mots ... et sont uniques dans notre cas :-) 
    set LesFungiOXOS [OiDescendants Fungi OXOS]
    set LesJoyOXOS [JoyCode ListOf OXOS]

    foreach OXOS $LesFungiOXOS {
        set Trouve 0
        if { ! [regexp {^([0-9]+) (.+)$} $OXOS Match OX OS]} { FaireLire "Wrong $OXOS" }
        #rR Je cherche d'abord s'il est un des Joy en OX
        foreach JoyOXOS $LesJoyOXOS {
            if { ! [regexp {^([0-9]+) (.+)$} $JoyOXOS Match JoyOX JoyOS]} { FaireLire "Wrong $JoyOXOS" }
            if {$OX==$JoyOX} {
                lappend LesElus $OXOS
                set Trouve 1
                set OkPour($OS) 1
                break
            }
        }
        if {$Trouve} { continue }
        #rR Je cherche ensuite s'il est un des Joy en OS
        foreach JoyOXOS $LesJoyOXOS {
            if { ! [regexp {^([0-9]+) (.+)$} $JoyOXOS Match JoyOX JoyOS]} { FaireLire "Wrong $JoyOXOS" }
            if {[info exists OkPour($OS)]} { set Trouve 1 ; break }
            if {[regexp "^$JoyOS" $OS]} {
                lappend LesElus $OXOS
                set Trouve 1
                break
            }
        }
        if {$Trouve} { continue }
        lappend LePeuple $OXOS
    }
    set LesJoyFungiOrdonnes {}
    lappend LesJoyFungiOrdonnes "JoysBand"
    LConcat LesJoyFungiOrdonnes $LesElus
    lappend LesJoyFungiOrdonnes "OtherFungi"
    LConcat LesJoyFungiOrdonnes $LePeuple
    if {$FileToCreate!=""} {
        SauveLesLignes $LesJoyFungiOrdonnes dans $FileToCreate
        return $FileToCreate
    }
    return $LesJoyFungiOrdonnes
}

proc OiDescendants {{Node ""} {GetWhat ""}} {
    #rR Attentionon utilise un fichier memo pour aller plus vite ... Penser à l'effacer si changement
    global OiDescendants
    if {$GetWhat==""} { set GetWhat OX }
    set Found 0
    if { ! $Found && [regexp -nocase "OX" $GetWhat] && [regexp -nocase "OS" $GetWhat]} { set Found 1; set GetWhat "OXOS" }
    if { ! $Found && [regexp -nocase "OX" $GetWhat]} { set Found 1; set GetWhat "OX" }
    if { ! $Found && [regexp -nocase "OS" $GetWhat]} { set Found 1; set GetWhat "OS" }
    if { ! $Found && [regexp -nocase "CL" $GetWhat]} { set Found 1; set GetWhat "CL" }
    if {[info exists OiDescendants($Node,$GetWhat)]} { return $OiDescendants($Node,$GetWhat) }
    if {[info exists OiDescendants($Node,Loaded)]} { return "" }
    set OiDescendants($Node,Loaded) 1
    set OiDescendants($Node,File) "[BlastomicsDir]/OiDescendants_$Node.txt"

    if {[file exists $OiDescendants($Node,File)]} {
        array set OiDescendants [ContenuDuFichier $OiDescendants($Node,File)]
        return [OiDescendants $Node $GetWhat]
    }

    set OxNode [Tax $Node "TaxId"]
    set LesClasses {}
    foreach OX [OiCode ListOf OX] {
	if { ! [JeSuisTonAncetre $OxNode $OX]} { continue }
	set Classe [TaxClass $OX Name]
        regsub {^ *; *cellular organisms; *} $Classe "" Classe 
	lappend LesClasses $Classe
	set OxDeLaClasse($Classe) $OX
    }
    set LesClasses [lsort $LesClasses]
    set LesOX {}
    set LesOS {}
    set LesOXOS {}
    foreach Classe $LesClasses {
	set OX $OxDeLaClasse($Classe)
	set OS [Tax $OX "Name"]
	lappend LesOX $OX
	lappend LesOS $OS
        lappend LesOXOS "$OX $OS"
    }
    set OiDescendants($Node,OXOS) $LesOXOS 
    set OiDescendants($Node,OX)   $LesOX 
    set OiDescendants($Node,OS)   $LesOS 
    set OiDescendants($Node,CL)   $LesClasses
    Sauve [array get OiDescendants] dans $OiDescendants($Node,File)
    return [OiDescendants $Node $GetWhat]
}

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

    set FichierMemo "/genomics/link/OI/fiches/phylar.txt"
    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $FichierMemo]} { file delete $FichierMemo }
	regsub -nocase "^ReDo_" $Qui "" Qui
	unset PhylAr
	return [PhylAr $Qui $Quoi]
    }
    if {[file exists $FichierMemo]} {
	array set PhylAr [ContenuDuFichier $FichierMemo]
	return [PhylAr $Qui $Quoi]
    }

    OiDomain Archaea

    set LesPhyOX [ArClade ListOf AllOX]
    set LesPhyOS [ArClade ListOf AllName]

    foreach OX [OiCode ListOf OX] {
	set OS [OiCode $OX OS]
	lappend PhylAr(ListOf,OX) $OX
	lappend PhylAr(ListOf,OS) $OS
	set PasTrouve 1
	foreach PhyOX $LesPhyOX {
	    set PhyOS [ArClade $PhyOX Name]
	    set PhylAr($PhyOX,PhyOX) $PhyOX
	    set PhylAr($PhyOX,PhyOS) $PhyOS
	    set PhylAr($PhyOS,PhyOX) $PhyOX
	    set PhylAr($PhyOS,PhyOS) $PhyOS

	    if {[JeSuisTonAncetre $PhyOX $OX]} {
		set PhylAr($OX,PhyOX) $PhyOX
		set PhylAr($OX,PhyOS) $PhyOS
		set PhylAr($OS,PhyOX) $PhyOX
		set PhylAr($OS,PhyOS) $PhyOS
		lappend PhylAr($PhyOX,ListOfOX) $OX
		lappend PhylAr($PhyOX,ListOfOS) $OS
		lappend PhylAr($PhyOS,ListOfOX) $OX
		lappend PhylAr($PhyOS,ListOfOS) $OS
		set PasTrouve 0
		break
	    }
	}
	if {$PasTrouve} { FaireLire "Impossible de caser\n$OX $OS"}
	
    }
    set LesPhyOXNonVides {}
    set LesPhyOYNonVides {}
    foreach PhyOX $LesPhyOX PhyOS $LesPhyOS {
	if { ! [info exists PhylAr($PhyOX,ListOfOX)]} { continue }
	lappend LesPhyOXNonVides $PhyOX
	lappend LesPhyOSNonVides $PhyOS
    }
    set PhylAr(ListOf,PhyOX) $LesPhyOXNonVides
    set PhylAr(ListOf,PhyOS) $LesPhyOSNonVides

    Sauve [array get PhylAr] dans $FichierMemo
    return [PhylAr $Qui $Quoi]
}


proc GeneIdWithGoDict {{Bdd ""}} {
}

proc TaxoblaProject {{Qui ""} {Quoi ""}} {
    global TaxoblaProject
    
    set FichierMemo "/genomics/link/OI/fiches/TaxoblaProject.txt"
    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $FichierMemo]} { file delete $FichierMemo }
	regsub -nocase "^ReDo_" $Qui "" Qui
	if {[info exists TaxoblaProject]} { unset TaxoblaProject }
	return [TaxoblaProject $Qui $Quoi]
    }
    
    if {[info exists TaxoblaProject($Qui,$Quoi)]} { return $TaxoblaProject($Qui,$Quoi) }
    if {[info exists TaxoblaProject("EstCharge")]} { return "" }
    set TaxoblaProject("EstCharge") 1
    
    if {[file exists $FichierMemo]} {
	array set TaxoblaProject [ContenuDuFichier $FichierMemo]
	return [TaxoblaProject $Qui $Quoi]
    }
    
    set LesRepExistants [glob -nocomplain "/genomics/link/*/taxobla"]
    foreach RepT $LesRepExistants {
	set Rep [file dirname $RepT]
	set LesProttfa [lsort [glob -nocomplain "$Rep/prottfa/*"]]
	if { [set NbProttfa [llength $LesProttfa]] < 10} { continue }
	set LesTaxobla [lsort [glob -nocomplain "$Rep/taxobla/*"]]
	set Projet [file tail $Rep]
	if { [set NbTaxobla [llength $LesTaxobla]] < $NbProttfa } { Espionne "$Projet $NbTaxobla/$NbProttfa" ; continue }
	lappend LesProjets [file tail $Rep]
	set OX [IntegerApres "NotreOX" dans [ContenuDuFichier "$Rep/beton/miniconfig"]]
	set TaxoblaProject($Projet,NS) $NbProttfa
	set TaxoblaProject($Projet,NT) $NbTaxobla
	set TaxoblaProject($Projet,OX) $OX
    }
    set TaxoblaProject(ListOf,Project) [lsort -unique $LesProjets]
    Sauve [array get TaxoblaProject] dans $FichierMemo
    return [TaxoblaProject $Qui $Quoi]
}

proc SshScore {{Query ""} {Subject ""}} {
    #rR SequenceSizeHomologyScore
    set OxQ [OiCode $Query   OX]
    set OxS [OiCode $Subject OX]
    set OiQ [OiCode $Query   OI]
    set OiS [OiCode $Subject OI]
}

proc Paraph {{Kind ""} {Qui ""} {Quoi ""}} {
    #rR Paraph (comme Paraphylum) est une généralisation de CMC ou TTLL ou PhylAr ...
    #rR Les Paraphylum of Kind
    #rR Attentin la même variable Paraph stocke tous les Kind ... est-ce que ça marche en même temps ? ???
    global Paraph

    set Separator " "           ; #rR a faire .. je ne sais pas comment ! 

    regsub -all "_" $Qui " " Qui

    if {[regexp -nocase "Help" $Qui]} {
	lappend LeHelp "Paraph Kind stands for Paraphylum of Kind"
	lappend LeHelp "Paraph ListOf Kind"
	lappend LeHelp "Paraph Kind ListOf Clade"
	lappend LeHelp "Paraph Kind ListOf OX"
	lappend LeHelp "Paraph Kind ListOf OS"
	lappend LeHelp "Paraph Kind 9606 Clade"
	lappend LeHelp "Paraph Kind Homo_sapiens Clade     -> Sarcopterygii     (eh oui !!! on est comme ça !!) "
	lappend LeHelp "Paraph Kind 9606 Clade             -> Sarcopterygii"
	lappend LeHelp "Paraph Kind Sarcopterygii OX       -> 7897 10090 9606 9913 9031 8364 8496 9258 13616 8469 28377"
	lappend LeHelp "Paraph Kind Sarcopterygii OS       -> lists the organism names" 
	lappend LeHelp "Paraph Kind 9606 OX                -> 9606"
	lappend LeHelp "Paraph Kind 9606 OS                -> Homo sapiens"
	lappend LeHelp "Paraph Kind Homo_sapiens OX        -> 9606              (nb : with underscore _ you don't need quotes) "
	lappend LeHelp "Paraph Kind Homo_sapiens OS        -> Homo sapiens"
	lappend LeHelp "Attention some Organims can belong to several Clades"
	lappend LeHelp "Paraph Kind 12345 Clade   may return several hits"
	lappend LeHelp ""
	lappend LeHelp "      Raymond"
	return [join $LeHelp "\n"]
    }

    set FichierCsv  "[BlastomicsDir]/Paraph_$Kind.csv"
    set FichierMemo "[BlastomicsDir]/Paraph_$Kind.txt"       
    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $FichierMemo]} { file delete $FichierMemo }
	regsub -nocase "^ReDo_" $Qui "" Qui
	return [Paraph $Kind $Qui $Quoi]
    }

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

    #rR Attention si on mémorise il faut faire redo quand il faut
    #rR Mais c'est pas la peine de mémoriser ça va vite ... sauf que j'ai perdu TTLL.csv 
    set OnMemorise 0
    
    if { $OnMemorise && [file exists $FichierMemo]} {
	array set Paraph [ContenuDuFichier $FichierMemo]
	set Paraph($Kind,csv,file) $FichierCsv
	return [Paraph $Qui $Quoi]
    }
    set Paraph($Kind,ListOf,Clade) {}
    foreach Ligne [LesLignesDuFichier $FichierCsv] {
	set A ""
	set B ""
        if {$Separator==";"} {
            lassign [split $Ligne ";"] A B
        } else {
            scan $Ligne "%s" A
            regsub "^$A *" $Ligne "" B
        }
	set A [string trim $A]
	set B [string trim $B]
	if {[regexp -nocase {[A-Z]} $A]} {
	    regsub -all " " $A "" A
	    set Clade $A
	    set Paraph($Kind,$Clade,OX) {}
	    set Paraph($Kind,$Clade,OS) {}
	    lappend Paraph($Kind,ListOf,Clade) $Clade
	    continue
	}
	if {[regexp {^[0-9]+$} $A]} {
	    set B [Tax $A Name]
	    lappend Paraph($Kind,$Clade,OX) $A
	    lappend Paraph($Kind,$Clade,OS) $B
	    lappend Paraph($Kind,$A,Clade) $Clade
	    lappend Paraph($Kind,$B,Clade) $Clade
	    lappend Paraph($Kind,ListOf,OX) $A
	    lappend Paraph($Kind,ListOf,OS) $B
	    set Paraph($Kind,$A,OX) $A
	    set Paraph($Kind,$A,OS) $B
	    set Paraph($Kind,$B,OX) $A
	    set Paraph($Kind,$B,OS) $B
	    continue
	}
    }
    set Paraph($Kind,ListOf,Clade) [lsort -unique $Paraph($Kind,ListOf,Clade)]
    set Paraph($Kind,ListOf,JoinedClade) [join $Paraph($Kind,ListOf,Clade) " "]
    set Paraph($Kind,ListOf,OX)     [lsort -unique $Paraph($Kind,ListOf,OX)]
    set Paraph($Kind,ListOf,OS)     [lsort -unique $Paraph($Kind,ListOf,OS)]
    if {$OnMemorise} { Sauve [array get Paraph] dans $FichierMemo }
    return [Paraph $Kind $Qui $Quoi]
}

proc TTLL {{Qui ""} {Quoi ""}} {
    #rR Les Clades pour les TTLL de Sarah Djeddi
    global TTLL

    regsub -all "_" $Qui " " Qui

    if {[regexp -nocase "Help" $Qui]} {
	lappend LeHelp "TTLL stands for Tubulin Tyrosine Ligase Like (from Sarah)"
	lappend LeHelp "TTLL ListOf Clade"
	lappend LeHelp "TTLL ListOf OX"
	lappend LeHelp "TTLL ListOf OS"
	lappend LeHelp "TTLL 9606 Clade"
	lappend LeHelp "TTLL Homo_sapiens Clade     -> Sarcopterygii     (eh oui !!! on est comme ça !!) "
	lappend LeHelp "TTLL 9606 Clade             -> Sarcopterygii"
	lappend LeHelp "TTLL Sarcopterygii OX       -> 7897 10090 9606 9913 9031 8364 8496 9258 13616 8469 28377"
	lappend LeHelp "TTLL Sarcopterygii OS       -> lists the organism names" 
	lappend LeHelp "TTLL 9606 OX                -> 9606"
	lappend LeHelp "TTLL 9606 OS                -> Homo sapiens"
	lappend LeHelp "TTLL Homo_sapiens OX        -> 9606              (nb : with underscore _ you don't need quotes) "
	lappend LeHelp "TTLL Homo_sapiens OS        -> Homo sapiens"
	lappend LeHelp "Attention some Organims can belong to several Clades"
	lappend LeHelp "TTLL 12345 Clade   may return several hits"
	lappend LeHelp ""
	lappend LeHelp "      Raymond"
	return [join $LeHelp "\n"]
    }

    set FichierCsv "[BlastomicsDbDir]/TTLL.csv"
    set Fichier    "/genomics/link/OI/fiches/TTLL.txt"
    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $Fichier]} { file delete $Fichier }
	regsub -nocase "^ReDo_" $Qui "" Qui
	return [TTLL $Qui $Quoi]
    }

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

    set OnMemorise 0                               ; #rR Attention si on mémorise il faut faire redo quand il faut
    if { $OnMemorise && [file exists $Fichier]} {
	array set TTLL [ContenuDuFichier $Fichier]
	set TTLL(csv,file) $FichierCsv
	return [TTLL $Qui $Quoi]
    }
    set TTLL(ListOf,Clade) {}
    foreach Ligne [LesLignesDuFichier $FichierCsv] {
	set A ""
	set B ""
	lassign [split $Ligne ";"] A B
	set A [string trim $A]
	set B [string trim $B]
	if {[regexp -nocase {[A-Z]} $A]} {
	    regsub -all " " $A "" A
	    set Clade $A
	    set TTLL($Clade,OX) {}
	    set TTLL($Clade,OS) {}
	    lappend TTLL(ListOf,Clade) $Clade
	    continue
	}
	if {[regexp {^[0-9]+$} $A]} {
	    set B [Tax $A Name]
	    lappend TTLL($Clade,OX) $A
	    lappend TTLL($Clade,OS) $B
	    lappend TTLL($A,Clade) $Clade
	    lappend TTLL($B,Clade) $Clade
	    lappend TTLL(ListOf,OX) $A
	    lappend TTLL(ListOf,OS) $B
	    set TTLL($A,OX) $A
	    set TTLL($A,OS) $B
	    set TTLL($B,OX) $A
	    set TTLL($B,OS) $B
	    continue
	}
    }
    set TTLL(ListOf,Clade) [lsort -unique $TTLL(ListOf,Clade)]
    set TTLL(ListOf,JoinedClade) [join $TTLL(ListOf,Clade) " "]
    set TTLL(ListOf,OX)     [lsort -unique $TTLL(ListOf,OX)]
    set TTLL(ListOf,OS)     [lsort -unique $TTLL(ListOf,OS)]
    if {$OnMemorise} { Sauve [array get TTLL] dans $Fichier }
    return [TTLL $Qui $Quoi]
}

proc CMC {{Qui ""} {Quoi ""}} {
    #rR Les Clades Multi Ciliés de Audrey
    global CMC

    regsub -all "_" $Qui " " Qui

    if {[regexp -nocase "Help" $Qui]} {
	lappend LeHelp "CMC stands for Clade Multi Cilia (from Audrey)"
	lappend LeHelp "CMC ListOf Clade"
	lappend LeHelp "CMC ListOf OX"
	lappend LeHelp "CMC ListOf OS"
	lappend LeHelp "CMC 9606 Clade"
	lappend LeHelp "CMC Homo_sapiens Clade     -> Sarcopterygii     (eh oui !!! on est comme ça !!) "
	lappend LeHelp "CMC 9606 Clade             -> Sarcopterygii"
	lappend LeHelp "CMC Sarcopterygii OX       -> 7897 10090 9606 9913 9031 8364 8496 9258 13616 8469 28377"
	lappend LeHelp "CMC Sarcopterygii OS       -> lists the organism names" 
	lappend LeHelp "CMC 9606 OX                -> 9606"
	lappend LeHelp "CMC 9606 OS                -> Homo sapiens"
	lappend LeHelp "CMC Homo_sapiens OX        -> 9606              (nb : with underscore _ you don't need quotes) "
	lappend LeHelp "CMC Homo_sapiens OS        -> Homo sapiens"
	lappend LeHelp "Attention some Organims can belong to several Clades"
	lappend LeHelp "CMC 12345 Clade   may return several hits"
	lappend LeHelp ""
	lappend LeHelp "      Raymond"
	return [join $LeHelp "\n"]
    }

    set FichierCsv "/home/defosset/Stage_M2/Groupes_Blastomics_Audrey.csv"
    set Fichier    "/genomics/link/OI/fiches/CladesMultiCilia.txt"
    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $Fichier]} { file delete $Fichier }
	regsub -nocase "^ReDo_" $Qui "" Qui
	return [CMC $Qui $Quoi]
    }

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

    set OnMemorise 0                               ; #rR Attention si on mémorise il faut faire redo quand il faut
    if { $OnMemorise && [file exists $Fichier]} {
	array set CMC [ContenuDuFichier $Fichier]
	set CMC(csv,file) $FichierCsv
	return [CMC $Qui $Quoi]
    }
    set CMC(ListOf,Clade) {}
    foreach Ligne [LesLignesDuFichier $FichierCsv] {
	set A ""
	set B ""
	lassign [split $Ligne ";"] A B
	set A [string trim $A]
	set B [string trim $B]
	if {[regexp -nocase {[A-Z]} $A]} {
	    set Clade $A
	    set CMC($Clade,OX) {}
	    set CMC($Clade,OS) {}
	    lappend CMC(ListOf,Clade) $Clade
	    continue
	}
	if {[regexp {^[0-9]+$} $A]} {
	    lappend CMC($Clade,OX) $A
	    lappend CMC($Clade,OS) $B
	    lappend CMC($A,Clade) $Clade
	    lappend CMC($B,Clade) $Clade
	    lappend CMC(ListOf,OX) $A
	    lappend CMC(ListOf,OS) $B
	    set CMC($A,OX) $A
	    set CMC($A,OS) $B
	    set CMC($B,OX) $A
	    set CMC($B,OS) $B
	    continue
	}
    }
    set CMC(ListOf,Clade) [lsort -unique $CMC(ListOf,Clade)]
    set CMC(ListOf,JoinedClade) [join $CMC(ListOf,Clade) " "]
    set CMC(ListOf,OX)     [lsort -unique $CMC(ListOf,OX)]
    set CMC(ListOf,OS)     [lsort -unique $CMC(ListOf,OS)]
    if {$OnMemorise} { Sauve [array get CMC] dans $Fichier }
    return [CMC $Qui $Quoi]
}

proc BestGeneId Nom {
    set G [NIAG $Nom G]
    if {$G!=""} { return $G }
}

proc NIAG {{Qui ""} {Quoi ""}} {
    #rR Pour passer du Nom au Id Ac et GeneId et inversement
    global NIAG

    if {[string equal -nocase "Help" $Qui]} {
	lappend LeHelp "NIAG stands for N=Nom I=UniprotId A=Accession G=Geneid"
	lappend LeHelp "NIAG ListOf N"
	lappend LeHelp "NIAG ListOf I"
	lappend LeHelp "NIAG ListOf A"
	lappend LeHelp "NIAG ListOf G"
	lappend LeHelp "NIAG HSAP00001 N     -> HSAP00001"
	lappend LeHelp "NIAG HSAP00001 I     -> 1433B_HUMAN"
	lappend LeHelp "NIAG HSAP00001 A     -> P31946"
	lappend LeHelp "NIAG HSAP00001 G     -> 7529"
	lappend LeHelp "NIAG 7529 N          -> HSAP00001"
	lappend LeHelp "NIAG 7529 I          -> ABCDEF_HUMAN"
	lappend LeHelp "NIAG 7529 A          -> Q12345"
	lappend LeHelp "NIAG 7529 G          -> 12345"
	lappend LeHelp "NIAG 1433B_HUMAN N   -> HSAP00001"
	lappend LeHelp "NIAG 1433B_HUMAN I   -> 1433B_HUMAN"
	lappend LeHelp "etc."
	lappend LeHelp "Attention a few UniprotIds and accession have several hits"
	lappend LeHelp "NIAG ABCDEF_HUMAN Ns    may return several hits (NIAG ABCDEF_HUMAN N  returns only the last one)"
	lappend LeHelp ""
	lappend LeHelp "      Raymond"
	return [join $LeHelp "\n"]
    }

    set Fichier "[RepertoireDuGenome]/fiches/niag.txt"
    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $Fichier]} { file delete $Fichier }
	regsub -nocase "^ReDo_" $Qui "" Qui
	return [NIAG $Qui $Quoi]
    }

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

    if {[file exists $Fichier]} {
	array set NIAG [ContenuDuFichier $Fichier]
	set NIAG(Filename,) $Fichier
	return [NIAG $Qui $Quoi]
    }

    set NIAG(ListOf,N) {}
    set NIAG(ListOf,A) {}
    set NIAG(ListOf,I) {}
    set NIAG(ListOf,G) {}
    foreach N [ListeDesPABs] {
	set I [ExtraitInfo $N "Id:"]
	set A [ExtraitInfo $N "Ac:"]
	set NIAG($N,N) $N
	set NIAG($N,I) $I
	set NIAG($N,A) $A
	if {$I!=""} {
	    set     NIAG($I,N)  $N     ; #rR tant pis s'il y a en a plusieurs, on prend le dernier
	    lappend NIAG($I,Ns) $N
	}
	if {$A!=""} {
	    set     NIAG($A,N)  $N     ; #rR tant pis s'il y a en a plusieurs, on prend le dernier
	    lappend NIAG($A,Ns) $N
	}
	lappend NIAG(ListOf,N) $N
	lappend NIAG(ListOf,I) $I
	lappend NIAG(ListOf,A) $A
    }

    set NIAG(ListOf,I) [lsort -unique $NIAG(ListOf,I)]
    set NIAG(ListOf,A) [lsort -unique $NIAG(ListOf,A)]
    set NIAG(ListOf,G) [lsort -unique $NIAG(ListOf,G)]

    #rR Attention là on met les Id puis les AC ... et si on trouve d'abord celui de l'Id tant mieux (car DejaVuCe)
    set LesDemandes [concat $NIAG(ListOf,I) $NIAG(ListOf,A)]
    set Res [IDMapping "ACC+ID" "GENEID" $LesDemandes]
    if {[info exists DejaVuCe]} { unset DejaVuCe }
    foreach X $LesDemandes G $Res {
        scan $G "%s" G
	set N $NIAG($X,N)
        if {[info exists DejaVuCe($N)]} { continue }
        set DejaVuCe($N) 1
	if {[regexp {00$} $N]} { Espionne "$N=$X=$G=" }
	if {$G==""} { continue }
	if {[info exists NIAG($N,G)]} {
	    if { $NIAG($N,G)==$G } { continue }
	    FaireLire "$N=$X=$G!=$NIAG($N,G)"
	}
	set NIAG($N,G) $G
    }

    foreach N $NIAG(ListOf,N) {
	if { ! [info exists NIAG($N,G)]} { continue }
	set G $NIAG($N,G)
	set NIAG($NIAG($N,I),G) $G 
	set NIAG($NIAG($N,A),G) $G
	set NIAG($G,N) $N
	set NIAG($G,I) $I
	set NIAG($G,A) $A
	lappend NIAG(ListOf,G) $G
    }
    set NIAG(ListOf,G) [lsort -unique $NIAG(ListOf,G)]
    Sauve [array get NIAG] dans $Fichier
    return [NIAG $Qui $Quoi]
}

proc ModelOrgaProject {{Qui ""} {Quoi ""}} {
    global MOP

    if {[regexp -nocase "Help" $Qui]} {
	lappend LeHelp "ModelOrgaProject ListOf O"
	lappend LeHelp "ModelOrgaProject ListOf P"
	lappend LeHelp "ModelOrgaProject ListOf OP"
	lappend LeHelp "ModelOrgaProject 9606 P"
	lappend LeHelp "ModelOrgaProject CilioCarta O"
	return [join $LeHelp "\n"]
    }

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

    set LaListe {}
    set LesFichierGoNoms [glob -nocomplain "/genomics/link/*/fiches/GoNoms.txt"]
    foreach Fichier $LesFichierGoNoms {
	set RepG [file dirname [file dirname $Fichier]]
	set O [IntegerApres "NotreOX" dans [ContenuDuFichier "$RepG/beton/miniconfig"]]
	if {$O==""} { continue }
	set L [llength [LesLignesDuFichier $Fichier]]
	Espionne "$L $O"
	if {$L<987} { continue }
	set P [file tail [file dirname [file dirname $Fichier]]]
	lappend MOP(ListOf,OP) "$O $P"
	lappend MOP(ListOf,O) $O
	lappend MOP(ListOf,P) $P
	lappend MOP($O,O) $O
	lappend MOP($O,P) $P
	set MOP($P,O) $O
	set MOP($P,P) $P
    }
    set MOP(ListOf,O) [lsort -unique $MOP(ListOf,O)]
    return [ModelOrgaProject $Qui $Quoi]
}

proc MyGOsFromModelOrga {} {
    
}

proc ModelOrgaGeneId {{Mod ""} {Qui ""} {Quoi ""}} {
    global MOGI

    set BackgroundDir "[BlastomicsDir]/data/GO/background"
    if {$Mod=="GetListOfModelTaxId"} {
	set LesTaxId {}
	foreach File [glob -nocomplain "$BackgroundDir/*"] {
	    set TaxId [file tail $File]
	    if {[regexp {[^0-9]} $TaxId]} { continue }
	    lappend LesTaxId $TaxId
	}
	return $LesTaxId
    }

    if { [regexp {[^0-9]} $Mod]} { set Mod [Tax $Mod TaxId] }

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

    set BackgroundFile "$BackgroundDir/$Mod"
    if {[FileAbsent $BackgroundFile]} { return "" }
    set MOGI($Mod,BackgroundFile,) $BackgroundFile
    foreach Ligne [LesLignesDuFichier $BackgroundFile] {
	scan $Ligne "%s %s" A G
	if { ! [regexp {^[0-9]+$} $G]} { continue }
	set MOGI($Mod,$A,)  $G
	set MOGI($Mod,$A,A) $A
	set MOGI($Mod,$A,G) $G
	set MOGI($Mod,$G)   $A
	set MOGI($Mod,$G,A) $A
	set MOGI($Mod,$G,G) $G
	lappend MOGI($Mod,ListOf,A) $A
	lappend MOGI($Mod,ListOf,G) $G
	lappend MOGI($Mod,ListOf,AG) "$A $G"
    }
    return [ModelOrgaGeneId $Mod $Qui $Quoi]
}



proc TestCladeCourant {} {
    Espionne [CladeCourant]
    Espionne [CladeCourant Insecta]
    Espionne [CladeCourant See]
    Espionne [CladeCourant New]
}

proc CladeCourant {{NewValue ""} {Format ""}} {
    JeMeSignale
    global CladeCourant

    if {$Format==""} { set Format "Name" }

    if {$NewValue=="IsSet"} {
	return [info exists CladeCourant]
    }
    if {$NewValue=="UnSet"} {
	if {[info exists CladeCourant]} { unset CladeCourant }
	return ""
    }
    if {$NewValue=="New"} {
	while {$NewValue=="New"} {
	    if {[OnTraite "CilioCarta" "Like"]} {
		set NewValue ""
		break
	    }
	    set NewValue [Entre "Mammalia"]
	    if {[Tax $NewValue]==""} {
		if {[OuiOuNon "Sorry $NewValue does not exist. Do I exit CladeCourant ?"]} { return "" }
		set NewValue "New"
		continue
	    }
	}
    }
    if {$NewValue=="See"} {
	set NewValue ""
	if {[info exists CladeCourant]} { return [FaireLire $CladeCourant] }
	return [FaireLire "Current Clade is not yet set"]
    }
    if {$NewValue!=""} {
	set Value [Tax $NewValue "Name"]
	set CladeCourant $Value
	return [Tax $CladeCourant $Format]
    }
    if {[info exists CladeCourant]} { return [Tax $CladeCourant $Format] }
    if {[OnTraite "CilioCarta" "Like"]} {
	set CladeCourant [SelectClade "One" "UseQds"]
	if {$CladeCourant==""} { set CladeCourant "Fungi" }
    }
    return [CladeCourant "New"]
    return [CladeCourant $CladeCourant $Format]
}

proc RunDeltaDistributionForClade {K {Method ""}} {    
    set Touche [$K find withtag current]
    set LesTags [$K gettags $Touche]
    lassign $LesTags Bidon Clade
    return [DeltaDistributionForClade $Clade {} {} $Method]
}

proc DeltaDistributionForClade {{Clade ""} {Seuil ""} {GetWhat ""} {Method ""} {Criteria ""}} {
    if {$Clade==""} { set Clade [SelectClade] }
    if {$Method==""} { set Method "Average" }
    if {$Criteria==""} { set Criteria "Rank" }

    set NomDeDistri [NomDe "Distri"]

    set EnTest [regexp {^(ripp|scherb)$} [Login]] 
    set EnTest 0

    if {$GetWhat==""}    { set GetWhat "Show" }
    if {$Seuil==""}      { set Seuil 0.001 }

    regsub -all " " $Clade "_" CladeUnderscore
    
    set Echantillonage 100
    
    set LesTaxIdsDuClade [CladeContent $Clade "UseQds" "Without,9606"]
	
    set NbTaxId [llength $LesTaxIdsDuClade]
    
    set Sens "increasing"
    if {[regexp -nocase "Score|DeltaS" $Criteria]} { set Sens "decreasing" }

    set Cadre $Clade
    foreach TaxId $LesTaxIdsDuClade {
	set OS [BilanCilioQds $TaxId "OS_"]
	set MethLogExp [TaxoBla $Cadre $TaxId-$Method LogExp]
	set MethScore  [TaxoBla $Cadre $TaxId-$Method Score]
	set MethRank   [TaxoBla $Cadre $TaxId-$Method Rank]
	set MethDeltaE [TaxoBla $Cadre $TaxId-$Method DeltaE]
	set MethDeltaS [TaxoBla $Cadre $TaxId-$Method DeltaS]
	set MethDeltaR [TaxoBla $Cadre $TaxId-$Method DeltaR]
Espionne "$Cadre $TaxId $Method $MethLogExp/$MethScore/$MethRank/$MethDeltaE/$MethDeltaS/$MethDeltaR"
	if {$MethRank==""} { continue }
	Espionne "$MethRank $OS $TaxId"
	lappend LesTaxIdDuMeth(LogExp,$MethLogExp) $TaxId
	lappend LesTaxIdDuMeth(Score,$MethScore)   $TaxId
	lappend LesTaxIdDuMeth(Rank,$MethRank)     $TaxId
	lappend LesTaxIdDuMeth(DeltaE,$MethDeltaE) $TaxId
	lappend LesTaxIdDuMeth(DeltaS,$MethDeltaS) $TaxId
	lappend LesTaxIdDuMeth(DeltaR,$MethDeltaR) $TaxId
	lappend LesMeth(LogExp) $MethLogExp
	lappend LesMeth(Score)  $MethScore
	lappend LesMeth(Rank)   $MethRank
	lappend LesMeth(DeltaE) $MethDeltaE
	lappend LesMeth(DeltaS) $MethDeltaS
	lappend LesMeth(DeltaR) $MethDeltaR
    }
    set LesMethCriteria [lsort -integer -$Sens $LesMeth($Criteria)]
    set LesTaxIdTries {}
    foreach MRank $LesMethCriteria {
	foreach TaxId $LesTaxIdDuMeth($Criteria,$MRank) {
	    Espionne $TaxId
	    if { ! [info exists DejaVu($TaxId)]} {set DejaVu($TaxId) 1 ; lappend LesTaxIdTries $TaxId }
	    set MethLogExp [TaxoBla $Cadre $TaxId-$Method LogExp]
	    set MethScore  [TaxoBla $Cadre $TaxId-$Method Score]
	    set MethRank   [TaxoBla $Cadre $TaxId-$Method Rank]
	    set MethDeltaE [TaxoBla $Cadre $TaxId-$Method DeltaE]
	    set MethDeltaS [TaxoBla $Cadre $TaxId-$Method DeltaS]
	    set MethDeltaR [TaxoBla $Cadre $TaxId-$Method DeltaR]
	    if {$MethRank==""} { continue }
	    Espionne "[BilanCilioQds $TaxId OS_]=$TaxId=$MethLogExp=$MethScore=$MethRank=$MethDeltaE=$MethDeltaS=$MethDeltaR"
	    Espionne [format "%-45s %-8s %6d %6d %6d %6d %6d %6d" [BilanCilioQds $TaxId "OS_"] $TaxId $MethLogExp $MethScore $MethRank $MethDeltaE $MethDeltaS $MethDeltaR]
	    set LesZonards {}
	    #rR Il faudrait commencer par remplir avec tout ce qui est avant le premier rang pour ne pas en perdre
	    #rR ........... mais il vaut mieux aoir le plus petit et le plus grand ...
	    foreach Ranks [RankSample "ListOfList" $Criteria] {
		set RankZone "[lindex $Ranks 0]-[lindex $Ranks end]"
		if { ! [info exists DejaVu($RankZone)]} { set DejaVu($RankZone) 1; lappend LesRankZones $RankZone }
#		set LesZonards {}
		foreach Rank $Ranks {
		    set ZonardsDuRank [TaxoBla $Cadre $TaxId-$Criteria-$Rank ListOfNom]
		    if {$ZonardsDuRank!=""} { LConcat LesZonards $ZonardsDuRank }
		}
		set NbZonards [llength $LesZonards]
		MemoZonards $NomDeDistri $TaxId-$RankZone $LesZonards set 
	    }
	}
    }
    MemoZonards $NomDeDistri "" "" unique
    set LesBeauxTaxIdTries {}
    set I 0
    foreach TaxId $LesTaxIdTries {
	lappend LesBeauxTaxIdTries "$TaxId [BilanCilioQds $TaxId OS_]"
	set J 0
	foreach RankZone $LesRankZones {
	    set N [llength [MemoZonards $NomDeDistri $TaxId-$RankZone]]
	    set T($I,$J) $N
	    incr J
	}
	incr I
    }
    set LeT [array get T]
    set K [Medals $LesBeauxTaxIdTries $LeT $LesRankZones "" "zonard" $NomDeDistri]

    set Titre "$Clade $Criteria distribution using $Method" 
    regsub ".canvas$" $K "" w
    wm title    $w $Titre
    wm iconname $w $Titre
    set B [BoutonneLaFenetre $w "Average Rank/DeltaR/DeltaE"]
    bind $B <1> "DeltaDistributionForClade $Clade $Seuil Show Average Rank"
    bind $B <2> "DeltaDistributionForClade $Clade $Seuil Show Average DeltaR"
    bind $B <3> "DeltaDistributionForClade $Clade $Seuil Show Average DeltaE"
    $B configure -background "Magenta"
    set B [BoutonneLaFenetre $w "First Rank/DeltaR"]
    bind $B "DeltaDistributionForClade $Clade $Seuil Show First Rank"
    bind $B <2> "DeltaDistributionForClade $Clade $Seuil Show First DeltaR"
    $B configure -background "Magenta"
    return $K
}

proc ShowZonards {K NomDeDistri} {
    set Touche [$K find withtag current]
    set LesTags [$K gettags $Touche]
    lassign $LesTags Distri I J Clade RankZone
    lassign [split $Clade "_"] TaxId 
    set LaSortie {}
    set LesNoms [MemoZonards $NomDeDistri $TaxId-$RankZone ListOfNom]
    foreach Nom $LesNoms {
	set Id [ExtraitInfo $Nom Id]
	set Ac [ExtraitInfo $Nom Ac]
	set ValiGN [ExtraitInfo $Nom ValiGN]
	lappend LesGn $ValiGN
	set ValiDE [ExtraitInfo $Nom ValiDE]
	lappend LaSortie "$Nom\t$Id\t$Ac\t$ValiGN\t$ValiDE"
    }
    set F [AfficheListe "#n°[PreFixe]\n$LaSortie" "AvecFetch" "Hits with at least $Distri for $Clade"]
    set GeneNames [join $LesGn ","]
    set Noms [join $LesNoms ","]
    set B [BoutonneLaFenetre $F "GeneOntology / Show Taxobla"]
    bind $B <1> "GoGetShowFromGeneList $GeneNames"
    bind $B <2> "SeeAby Taxobla \[selection get\]"
    $B configure -background "Magenta"
    set B [BoutonneLaFenetre $F "Homo sapiens Hits/ Info/ GOs"]
    bind $B <1> "ShowHsapHits \[set PagePropre($F)\] Hits"
    bind $B <2> "ShowHsapHits \[set PagePropre($F)\] Info"
    bind $B <3> "ShowHsapHits \[set PagePropre($F)\] GO"
    $B configure -background "Orange"
}

proc ShowHsapHits {LesNoms {Quoi ""} {RefTaxId ""}} {
    JeMeSignale

    set Science "CilioCarta"
    if {[OnTraite OI2017 Like]} { set Science "EHomsa" }

    if {[regexp "\n" $LesNoms]} {
	set LesNomsLus {}
	foreach Ligne [split $LesNoms "\n"] {
	    if {[regexp "^#" $Ligne]} { continue }
	    scan $Ligne "%s" NomLu
	    lappend LesNomsLus $NomLu
	}
	set LesNoms $LesNomsLus
    }
    if {[regexp "," $LesNoms]} { set LesNoms [split $LesNoms ","] }
    if {$Quoi==""} { set Quoi "Info" }
    if {$RefTaxId==""} { set RefTaxID 9606 } 
    set LesHsapGeneNames {}
    set LesHsapInfo {}
    set LesHsap {}
    foreach Nom $LesNoms {
	set FicTaxobla [GscopeFile $Nom "taxobla"]
	if {[FileAbsent $FicTaxobla]} { continue }
	foreach Ligne [LesLignesDuFichier $FicTaxobla] {
	    lassign [split $Ligne "\t"] PN Score TaxId Orga Info
	    set TaxId [string trim $TaxId]
	    if { ! [string equal $RefTaxID $TaxId]} { continue }
	    set Access [string trim [lindex [split $Info " "] 1]]
	    set Hsap [QuestionDeScience $Science "ret RepereBox $Access"]
	    if {$Hsap==""} { continue }
	    set HsapGN [QuestionDeScience $Science "ret BestGN $Hsap"]
	    set HsapDE [QuestionDeScience $Science "ret BestDE $Hsap"]
	    lappend LesHsapGeneNames $HsapGN
	    lappend LesHsapInfo "$Nom first Hsap hit: $Hsap $HsapGN $HsapDE"
	    lappend LesHsap $Hsap
	}
    }
    if {$Quoi=="GO"  } { return [GoGetShowFromGeneList $LesHsapGeneNames] }
    if {$Quoi=="Info"} { return [AfficheListe $LesHsapInfo] }
    return 
}

proc CladesDistribution {{Method ""} {Criteria ""}} {

    if {$Criteria==""} { set Criteria "Rank" }
    if {$Method==""}   { set Method "Average" }
    
    set NomDeClaDistri [NomDe "ClaDistri"]

    foreach Clade [SelectClade "Multiple" "UseQds"] {
	set Cadre $Clade
	set MethCrit [TaxoBla $Cadre $Method $Criteria]
	if {$MethCrit==""} { continue }
	lappend LesCladeDuMethCrit($MethCrit) $Clade
	lappend LesMethCrit $MethCrit
	Espionne "$Clade $MethCrit"
    }
    set Sens "increasing"
    if {[regexp -nocase "Score" $Criteria]} { set Sens "decreasing" }
    set LesMethCrit [lsort -integer -$Sens [set LesMethCrit]]
    set LesCladesTries {}
    foreach MCrit $LesMethCrit {
Espionne "MCrit $MCrit"
	foreach Clade [set LesCladeDuMethCrit($MCrit)] {
	    set Cadre $Clade
	    if { ! [info exists DejaVu($Clade)]} {set DejaVu($Clade) 1 ; lappend LesCladesTries $Clade }
	    set MethCrit [TaxoBla $Cadre $Method $Criteria]
	    Espionne [format "%-18s %6d" $Clade $MethCrit]
	    foreach Crits [RankSample "ListOfList" $Criteria] {
Espionne "$Crits"
		set CritZone "[lindex $Crits 0]-[lindex $Crits end]"
		if { ! [info exists DejaVu($CritZone)]} { set DejaVu($CritZone) 1; lappend LesCritZones $CritZone }
		set LesZonards {}
		foreach Crit $Crits {
		    set ZonardsDuCrit [TaxoBla $Cadre ${Method}$Criteria-$Crit ListOfNom]
		    if {$ZonardsDuCrit!=""} { LConcat LesZonards $ZonardsDuCrit }
		}
		set NbZonards [llength $LesZonards]
		MemoZonards $NomDeClaDistri $Clade-$CritZone $LesZonards set 
	    }
	}
    }
    MemoZonards $NomDeClaDistri "" "" unique
    set I 0
    foreach Clade $LesCladesTries {
	set J 0
	foreach CritZone $LesCritZones {
	    set N [llength [MemoZonards $NomDeClaDistri $Clade-$CritZone]]
	    set T($I,$J) $N
	    incr J
	}
	incr I
    }
    set LeT [array get T]
    set K [Medals $LesCladesTries $LeT $LesCritZones "" "zonard" $NomDeClaDistri]
    regsub ".canvas" $K "" w
    set Titre "CladesDistribution $Method $Criteria"
    wm title    $w $Titre
    wm iconname $w $Titre
    set B [BoutonneLaFenetre $w "Clades Rank Distribution Average/ First"]
    bind $B <1> "CladesDistribution Average"
    bind $B <2> "CladesDistribution First"
    $B configure -background "Magenta"
    set B [BoutonneLaFenetre $w "Clades Score Distribution Average/ First"]
    bind <1> "CladesDistribution Average Score"
    bind $B <2> "CladesDistribution First Score"
    $B configure -background "Magenta"
    set B [BoutonneLaFenetre $w "Clades Expect Distribution Average/ First"]
    bind $B <1> "CladesDistribution Average LogExp"
    bind $B <2> "CladesDistribution First LogExp"
    $B configure -background "Magenta"
    return $K
}


proc MemoZonards {{Qui ""} {Quoi ""} {Valeur ""} {Action ""}} {
    global MemoZonards
    if {$Action==""} { set Action "get" }
    if {$Action=="get"} {
	if {[info exists MemoZonards($Qui,$Quoi)] } { return $MemoZonards($Qui,$Quoi) }
	return ""
    }  
    if {$Action=="Reset"}  { if {[info exists MemoZonards($Qui,$Quoi)] } { unset MemoZonards($Qui,$Quoi) } ; return "" }  
    if {$Action=="set"}    { set     MemoZonards($Qui,$Quoi) $Valeur ; return $MemoZonards($Qui,$Quoi) }  
    if {$Action=="append"} { lappend MemoZonards($Qui,$Quoi) $Valeur ; return $MemoZonards($Qui,$Quoi) }  
    if {$Action=="unique"} {
	foreach {K V} [array get MemoZonards] {
	    set MemoZonards($K) [ListeSansDoublon $V]
	}
    }  
    return ""
}

proc RankSample {{What ""} {Criteria ""}} {
    set Increment 1
    if {$Criteria==""} { set Criteria "Rank" }
    if {$Criteria=="Rank"}   { set RankSample [list 1 2 3 4 5 7 8 9 10 15 20 25 30 35 40 45 50 55 60 70 75 80 90 101] }
    if {$Criteria=="DeltaR"} { set RankSample [concat [list -100] [NombresEntre  -75 50    5] [list   100]] }
    if {$Criteria=="DeltaE"} { set RankSample [concat [list -250] [NombresEntre -220 50    5] [list  -250]] }
    if {$Criteria=="DeltaS"} { set RankSample [concat [list 9000] [NombresEntre 3000  0 -100]             ] ; set Increment -1 }
    if {$Criteria=="Score"}  { set RankSample [concat [list 9000] [NombresEntre 3000  0 -100] [list -3000]] ; set Increment -1 }
    if {$Criteria=="LogExp"} { set RankSample [concat [list -250] [NombresEntre -220  0    5] ] }
    set RankSampleDeb {}
    set RankSampleFin {}
    foreach D [lrange $RankSample 0 end-1] F [lrange $RankSample 1 end] {
	incr F -1
	lappend RankSampleDeb $D
	lappend RankSampleFin $F
    }
    foreach D $RankSampleDeb F $RankSampleFin {
	lappend RankSampleLimits "$D-$F"
    }
    if {$What=="List"} { return $RankSample }
    if {$What=="ListOfList"} {
	set LL {}
	foreach D $RankSampleDeb F $RankSampleFin {
	    lappend LL [NombresEntre $D $F $Increment]
	}
	return $LL
    }
}

proc OlymCladeHelp {{GetWhat ""}} {
    set Texte "
OlymClade permet de comparer et de voir les distributions des positions du premier hit de chaque organisme dans les blastp

Avant tout il faut bien retenir que
1/ l'on part de taxobla qui contient dans l'ordre du blast les positions du premier hit de chaque organisme
   chaque ligne contient séparés par tabulation (et des blancs en fin de valeur, mais a partir de SuiteInfo il n'y a plus de tab)
   expect  score   taxid  OC                                      Suite info
   1e-73   234     88036  Selaginella moellendorffii (strand ...  D8RPE7_SELML D8RPE7 Selaginella moellendorffii Ubiquinol oxidase GN=SELMODRAFT_232012 OS=Selaginella_moellendorffii TAXID=88036 BANK=tr OX=88036 Length = 302
   
2/   
"
    if {$GetWhat=="Show"} { return [Affiche $Texte] }
    return $Texte
}

proc NiceRank {AbsRank MaxPossible} {
    set NiceRank(1) 1
    set NiceRank(2) 2
    set NiceRank(3) 3
    set NiceRank(4) 4
    set NiceRank(5) 5
    set NiceRank(6) 6
    set NiceRank(7) 7
    set NiceRank(8) 8
    set NiceRank(9) 9
    if {[info exists NiceRank(AbsRank)]} { return $NiceRank(AbsRank) }
    set Rank [expr int(($AbsRank-9)*100/$MaxPossible) + 10]
    return $Rank
} 

proc TaxoBla {{Cadre ""} {Qui ""} {Quoi ""}} {
    #rR TaxoBla stocke tout ce qu'il peut pour tous les CladeDistrbution ci-dessus
    #rR En fait Cadre est censé être du style Clade_0.001_FirstOnly_UseExpect
    #rR On peut donc faire l'étude d'un clade dans plusieurs cadres ;)
    #rR attention Expect est le vrai expect ... LogExp = log10($Expect)
    #rR attention Expect est le vrai expect ... LogExp = log10($Expect)
    #rR attention Expect est le vrai expect ... LogExp = log10($Expect)
    #rR attention Expect est le vrai expect ... LogExp = log10($Expect)
    #rR TaxoBla lit les fichiers taxobla où ne figure qu'une fois chaque organisme... 
    #rR     FirstOnly concerne le First d'un Clade ...

    #rR Petite remarque : les Rank et LogExpect sont croissants, les Score sont décroissants
    #rR DeltaE va de -250 à +250
    #rR DeltaS de 3000 à -3000
    #rR DeltaR de -100 à +100

    global TaxoBla
	
    if {[info exists TaxoBla($Cadre,$Qui,$Quoi)]}  { return $TaxoBla($Cadre,$Qui,$Quoi) }
    if {[info exists TaxoBla($Cadre,"EstCharge")]} { return "" }
    if {[regexp {^New_(.+)} $Cadre Match CadreLu]} {
	foreach Name [array names TaxoBla -glob "$CadreLu,*"] {
	    unset TaxoBla($Name)
	}
	set Cadre $CadreLu
	set FichierTaxoBla [Fiches "taxobla_$Cadre.txt"]
	if {[file exists $FichierTaxoBla]} { file delete $FichierTaxoBla }
    }
    set TaxoBla($Cadre,"EstCharge") 1

    set Clade ""
    set Seuil ""
    set SelectMethod ""
    set UseExpect ""
    lassign [split $Cadre "_"] Clade Seuil SelectMethod UseExpect


    if {[OnTraite CilioCarta Like]} {
	set LesTaxId [CladeContent $Clade "UseQds" "Without,[NotreOX]"]
    } elseif {[OnTraite OI2017 Like]} {
	set LesTaxId [CladeContentWithinOi2017 $Clade]
    } else {
	FaireLire "Désolé. Il faut être CilioCarta Like ou OI2017 Like ..."
    }
    set LesOS {}
    foreach TaxId $LesTaxId {
	set OS [join [Tax $TaxId Name] "_"]
	lappend LesOS $OS
    }
    if {$Seuil==""}        { set Seuil 0.001 }  
    if {$SelectMethod==""} { set SelectMethod "FirstOnly" }  
    if {$UseExpect==""}    { set USeExpect "UseExpect" } 

    set TaxoBla($Cadre,Cadre,)        $Cadre
    set TaxoBla($Cadre,ListOf,TaxId)  $LesTaxId
    set TaxoBla($Cadre,ListOf,OS)     $LesOS
    set TaxoBla($Cadre,Seuil,)        $Seuil
    set TaxoBla($Cadre,SelectMethod,) $SelectMethod
    set TaxoBla($Cadre,UseExpect,)    $UseExpect
    set TaxoBla($Cadre,ListOf,DeltaE) {}
    set TaxoBla($Cadre,ListOf,DeltaS) {}
    set TaxoBla($Cadre,ListOf,DeltaR) {}

    set FichierTaxoBla [Fiches "taxobla_$Cadre.txt"]
    set TaxoBla($Cadre,file,) $FichierTaxoBla

    #rR Attention ici on lit le fichier memorisé ... à effacer s'il faut le refaire
    if {[file exists $FichierTaxoBla]} {
	array set TaxoBla [LesLignesDuFichier $FichierTaxoBla]
	return [TaxoBla $Cadre $Qui $Quoi]
    }

    if {$LesTaxId=={}} { return [TaxoBla $Cadre $Qui $Quoi] }

    foreach TaxId $LesTaxId {
	set TaxoBla($Cadre,$TaxId-Sum,LogExp) 0
	set TaxoBla($Cadre,$TaxId-Sum,Score)  0
	set TaxoBla($Cadre,$TaxId-Sum,Rank)   0
	set TaxoBla($Cadre,$TaxId-Sum,DeltaE) 0
	set TaxoBla($Cadre,$TaxId-Sum,DeltaS) 0
	set TaxoBla($Cadre,$TaxId-Sum,DeltaR) 0
    }

    set SumAllLogExp 0
    set SumAllScore  0
    set SumAllRank   0
    set SumAllFirstLogExp 0
    set SumAllFirstScore  0
    set SumAllFirstRank   0
    set SumAllDeltaE 0
    set SumAllDeltaS 0
    set SumAllDeltaR 0
    set NbNom 0
    foreach Nom [ListeDesPABs] {
	set TaxoBla($Cadre,$Nom,ListOfTaxId) {}
	set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]]
	if {$LesOrgaTrie=={}} { continue }
	set LesChoisis {}
	set FirstTaxId ""
	set Ieme 0
	set NbHits 0
	foreach Ligne $LesOrgaTrie {
	    incr Ieme
	    #rR je rappelle que taxobla ne contient qu'une fois chaque organisme
	    lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
	    set TaxId  [string trim $TaxId]
	    if {[lsearch $LesTaxId $TaxId]<0} { continue }	

	    if {$Expect==0.0} { set Expect 1.0e-250 }
	    #if {$Expect >1.0} { set Expect 1.0 }
	    set OS     [string trim $OS]
	    set Reste  [string trim $Reste]
	    
	    set Expect [string trim $Expect]
	    set Score  [expr round([string trim $Score])]
	    set BonSeuil  $Seuil
	    if {[regexp -nocase "^e" $Seuil]} { set BonSeuil "1.0$Seuil" }
	    if {$Expect > $BonSeuil} { break }

	    incr NbHits
	    if { ! [info exists DejaVu($Nom)]} { set DejaVu($Nom) 1 ; lappend TaxoBla($Cadre,ListOf,Nom) $Nom }

	    set LogExp [expr round(log10($Expect))]       ;#rR on passe en log !!!!!!!!!!!!!!!!!
	    set AbsRank $Ieme

	    lappend LesLogExps $LogExp
	    lappend LesScores  $Score
	    lappend TaxoBla($Cadre,$Nom,ListOfTaxId) $TaxId
	    set TaxoBla($Cadre,$Nom-$TaxId,Expect)  $Expect
	    set TaxoBla($Cadre,$Nom-$TaxId,LogExp)  $LogExp
	    set TaxoBla($Cadre,$Nom-$TaxId,Score)   $Score
	    set TaxoBla($Cadre,$Nom-$TaxId,AbsRank) $AbsRank
	    if {$FirstTaxId==""} {
		set FirstTaxId $TaxId
		set FirstLogExp  $LogExp
		set FirstScore   $Score
		set FirstAbsRank $AbsRank
		set TaxoBla($Cadre,$Nom-First,TaxId)   $TaxId
		set TaxoBla($Cadre,$Nom-First,LogExp)  $LogExp
		set TaxoBla($Cadre,$Nom-First,Score)   $Score
		set TaxoBla($Cadre,$Nom-First,AbsRank) $AbsRank
		lappend TaxoBla($Cadre,FirstTaxId-$TaxId,ListOfNom) $Nom
		set TaxoBla($Cadre,$TaxId-First,LogExp) $LogExp
		set TaxoBla($Cadre,$TaxId-First,Score)  $Score
	    }
	    set TaxoBla($Cadre,$TaxId-Sum,LogExp)  [expr $TaxoBla($Cadre,$TaxId-Sum,LogExp)  + $LogExp]
	    set TaxoBla($Cadre,$TaxId-Sum,Score)   [expr $TaxoBla($Cadre,$TaxId-Sum,Score)   + $Score]
	    lappend TaxoBla($Cadre,$TaxId,ListOfNom) $Nom
	}
	set NbHitsInBlast $Ieme
	set TaxoBla($Cadre,$Nom,NbHits) $NbHits
	if {$NbHits==0} { continue}
	incr NbNom
	set SumLogExp 0
	set SumScore 0
	set SumRank 0
	foreach TaxId $TaxoBla($Cadre,$Nom,ListOfTaxId) {
	    #set Rank [expr $TaxoBla($Cadre,$Nom-$TaxId,AbsRank)*100/$NbHitsInBlast]
	    set Rank [NiceRank $TaxoBla($Cadre,$Nom-$TaxId,AbsRank) $NbHitsInBlast]
	    set TaxoBla($Cadre,$Nom-$TaxId,Rank) $Rank
	    if {$TaxId==$FirstTaxId} {
		set TaxoBla($Cadre,$Nom-First,Rank)   $Rank
		set TaxoBla($Cadre,$TaxId-First,Rank) $Rank
		set FirstRank                         $Rank
	    }
	    set SumLogExp [expr $SumLogExp + $TaxoBla($Cadre,$Nom-$TaxId,LogExp)]
	    set SumScore  [expr $SumScore  + $TaxoBla($Cadre,$Nom-$TaxId,Score)]
	    set SumRank   [expr $SumRank   + $TaxoBla($Cadre,$Nom-$TaxId,Rank)]
	}
	set AverageLogExp [expr round($SumLogExp / $NbHits)]
	set AverageScore  [expr round($SumScore / $NbHits)]
	set AverageRank   [expr max(1,round($SumRank / $NbHits))] ;#rR j'ai mis 1 minimum
	#set AverageRank   [expr max(1,[NiceRank $SumRank $NbHits])] ;#rR j'ai mis 1 minimum
	set TaxoBla($Cadre,$Nom-Average,LogExp) $AverageLogExp
	set TaxoBla($Cadre,$Nom-Average,Score)  $AverageScore
	set TaxoBla($Cadre,$Nom-Average,Rank)   $AverageRank
	lappend TaxoBla($Cadre,AverageLogExp-$AverageLogExp,ListOfNom) $Nom
	lappend TaxoBla($Cadre,AverageScore-$AverageScore,ListOfNom)   $Nom
	lappend TaxoBla($Cadre,AverageRank-$AverageRank,ListOfNom)     $Nom
	lappend TaxoBla($Cadre,FirstLogExp-$FirstLogExp,ListOfNom)     $Nom
	lappend TaxoBla($Cadre,FirstScore-$FirstScore,ListOfNom)       $Nom
	lappend TaxoBla($Cadre,FirstRank-$FirstRank,ListOfNom)         $Nom
	set SumDeltaE 0
	set SumDeltaS 0
	set SumDeltaR 0
	foreach TaxId $TaxoBla($Cadre,$Nom,ListOfTaxId) {
	    set DeltaE [expr round($TaxoBla($Cadre,$Nom-$TaxId,LogExp) - $TaxoBla($Cadre,$Nom-Average,LogExp))]
	    set DeltaS [expr round($TaxoBla($Cadre,$Nom-$TaxId,Score)  - $TaxoBla($Cadre,$Nom-Average,Score))]
	    set DeltaR [expr round($TaxoBla($Cadre,$Nom-$TaxId,Rank)   - $TaxoBla($Cadre,$Nom-Average,Rank))]
	    set TaxoBla($Cadre,$TaxId-First,DeltaE) $DeltaE
	    set TaxoBla($Cadre,$TaxId-First,DeltaS) $DeltaS
	    set TaxoBla($Cadre,$TaxId-First,DeltaR) $DeltaR
	    incr SumDeltaE $DeltaE
	    incr SumDeltaS $DeltaS
	    incr SumDeltaR $DeltaR
	    set TaxoBla($Cadre,$Nom-$TaxId,DeltaE) $DeltaE
	    set TaxoBla($Cadre,$Nom-$TaxId,DeltaS) $DeltaS
	    set TaxoBla($Cadre,$Nom-$TaxId,DeltaR) $DeltaR
	    lappend TaxoBla($Cadre,DeltaE-$DeltaE,ListOfNom) $Nom
	    lappend TaxoBla($Cadre,DeltaS-$DeltaS,ListOfNom) $Nom
	    lappend TaxoBla($Cadre,DeltaR-$DeltaR,ListOfNom) $Nom
	    lappend TaxoBla($Cadre,ListOf,DeltaE) $DeltaE
	    lappend TaxoBla($Cadre,ListOf,DeltaS) $DeltaS
	    lappend TaxoBla($Cadre,ListOf,DeltaR) $DeltaR
	    set LogExp $TaxoBla($Cadre,$Nom-$TaxId,LogExp)
	    set Score  $TaxoBla($Cadre,$Nom-$TaxId,Score)
	    set Rank   $TaxoBla($Cadre,$Nom-$TaxId,Rank)
	    lappend TaxoBla($Cadre,ListOf,LogExp) $LogExp
	    lappend TaxoBla($Cadre,ListOf,Score)  $Score
	    lappend TaxoBla($Cadre,ListOf,Rank)   $Rank
	    lappend TaxoBla($Cadre,$TaxId-LogExp-$LogExp,ListOfNom) $Nom
	    lappend TaxoBla($Cadre,$TaxId-Score-$Score,ListOfNom)   $Nom
	    lappend TaxoBla($Cadre,$TaxId-Rank-$Rank,ListOfNom)     $Nom
	    lappend TaxoBla($Cadre,$TaxId-DeltaE-$DeltaE,ListOfNom) $Nom
	    lappend TaxoBla($Cadre,$TaxId-DeltaS-$DeltaS,ListOfNom) $Nom
	    lappend TaxoBla($Cadre,$TaxId-DeltaR-$DeltaR,ListOfNom) $Nom
	    set TaxoBla($Cadre,$TaxId-Sum,Rank)   [expr $TaxoBla($Cadre,$TaxId-Sum,Rank) + $Rank]
	    set TaxoBla($Cadre,$TaxId-Sum,DeltaE) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaE) + $DeltaE]
	    set TaxoBla($Cadre,$TaxId-Sum,DeltaS) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaS) + $DeltaS]
	    set TaxoBla($Cadre,$TaxId-Sum,DeltaR) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaR) + $DeltaR]
	}
	set TaxoBla($Cadre,$Nom-Average,DeltaE) [expr round($SumDeltaE / $NbHits)]
	set TaxoBla($Cadre,$Nom-Average,DeltaS) [expr round($SumDeltaS / $NbHits)]
	set TaxoBla($Cadre,$Nom-Average,DeltaR) [expr round($SumDeltaR / $NbHits)]
	set SumAllLogExp  [expr $SumAllLogExp + $TaxoBla($Cadre,$Nom-Average,LogExp)]
	set SumAllScore   [expr $SumAllScore  + $TaxoBla($Cadre,$Nom-Average,Score)]
	set SumAllRank    [expr $SumAllRank   + $TaxoBla($Cadre,$Nom-Average,Rank)]
	set SumAllDeltaE  [expr $SumAllDeltaE + $TaxoBla($Cadre,$Nom-Average,DeltaE)]
	set SumAllDeltaS  [expr $SumAllDeltaS + $TaxoBla($Cadre,$Nom-Average,DeltaS)]
	set SumAllDeltaR  [expr $SumAllDeltaR + $TaxoBla($Cadre,$Nom-Average,DeltaR)]
	set SumAllFirstLogExp  [expr $SumAllFirstLogExp + $TaxoBla($Cadre,$Nom-First,LogExp)]
	set SumAllFirstScore   [expr $SumAllFirstScore  + $TaxoBla($Cadre,$Nom-First,Score)]
	set SumAllFirstRank    [expr $SumAllFirstRank   + $TaxoBla($Cadre,$Nom-First,Rank)]
    } ;#rR fin de la boucle sur Nom
    set TaxoBla($Cadre,ListOf,LogExp) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,LogExp)]
    set TaxoBla($Cadre,ListOf,Score)  [lsort -unique -integer -decreasing $TaxoBla($Cadre,ListOf,Score)]
    set TaxoBla($Cadre,ListOf,Rank)   [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,Rank)]
    set TaxoBla($Cadre,ListOf,DeltaE) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,DeltaE)]
    set TaxoBla($Cadre,ListOf,DeltaS) [lsort -unique -integer -decreasing $TaxoBla($Cadre,ListOf,DeltaS)]
    set TaxoBla($Cadre,ListOf,DeltaR) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,DeltaR)]
    set TaxoBla($Cadre,Average,LogExp) [expr $SumAllLogExp/$NbNom]
    set TaxoBla($Cadre,Average,Score)  [expr $SumAllScore/$NbNom]
    set TaxoBla($Cadre,Average,Rank)   [expr $SumAllRank/$NbNom]
    set TaxoBla($Cadre,Average,DeltaE) [expr $SumAllDeltaE/$NbNom]
    set TaxoBla($Cadre,Average,DeltaS) [expr $SumAllDeltaS/$NbNom]
    set TaxoBla($Cadre,Average,DeltaR) [expr $SumAllDeltaR/$NbNom]
    set TaxoBla($Cadre,First,LogExp)   [expr $SumAllFirstLogExp/$NbNom]
    set TaxoBla($Cadre,First,Score)    [expr $SumAllFirstScore/$NbNom]
    set TaxoBla($Cadre,First,Rank)     [expr $SumAllFirstRank/$NbNom]

    foreach TaxId $LesTaxId {
	if { ! [info exists TaxoBla($Cadre,$TaxId,ListOfNom)]} { continue }
	set N [llength $TaxoBla($Cadre,$TaxId,ListOfNom)]
	set TaxoBla($Cadre,$TaxId-Average,LogExp) [expr $TaxoBla($Cadre,$TaxId-Sum,LogExp)/$N]
	set TaxoBla($Cadre,$TaxId-Average,Score)  [expr $TaxoBla($Cadre,$TaxId-Sum,Score)/$N]
	set TaxoBla($Cadre,$TaxId-Average,Rank)   [expr $TaxoBla($Cadre,$TaxId-Sum,Rank)/$N]   ; set TaxoBla($Cadre,$TaxId-Average,Rank) [expr max(1,$TaxoBla($Cadre,$TaxId-Average,Rank))]
	set TaxoBla($Cadre,$TaxId-Average,DeltaE) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaE)/$N]
	set TaxoBla($Cadre,$TaxId-Average,DeltaS) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaS)/$N]
	set TaxoBla($Cadre,$TaxId-Average,DeltaR) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaR)/$N]
    }


    SauveLesLignes [array get TaxoBla "$Cadre,*"] dans $FichierTaxoBla
    return [TaxoBla $Cadre $Qui $Quoi]
}

proc MemOlym {{Qui ""} {Quoi ""} {Valeur ""}} {
    global MemOlym
    
    set Qui  [string trim $Qui]
    set Quoi [string trim $Quoi]

    if {$Qui=="Reset"} {
	if {[info exists MemOlym]} { unset MemOlym }
	return ""
    }
    
    if {$Valeur==""} {
	if {[info exists MemOlym($Qui,$Quoi)]}  { return $MemOlym($Qui,$Quoi) }
	if {[info exists MemOlym("EstCHarge")]} { return "" }
    }
    set MemOlym("EstCHarge") 1
    lappend MemOlym($Qui,$Quoi) $Valeur
    return [MemOlym $Qui $Quoi]
}

proc LesHitsAvecDelta {Nom LesOrganismesInteressants {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {
    if {$UseExpect==""}    { set UseExpect "UseExpect" }
    set UseExp [string equal -nocase "UseExpect" $UseExpect]

    if {$SelectMethod==""} { set SelectMethod "FirstOnly" }	
    if {$GetWhat==""}      { set GetWhat "Show" }
    if {$Seuil==""}        { set Seuil 99999 }

    if {[regexp -nocase "Best"  $SelectMethod]} { set SelectMethode "BestOnly" }
    if {[regexp -nocase "First" $SelectMethod]} { set SelectMethode "FirstOnly" }
    if {[regexp -nocase "Ave"   $SelectMethod]} { set SelectMethode "AboveAverage" }
    if {$LesOrganismesInteressants=={}} { return {} }
    
    set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]]
    if {$LesOrgaTrie=={}} { return {} }
    set LesChoisis {}
    set PremierTaxId ""
    foreach Ligne $LesOrgaTrie {
	#rR je rappelle que taxobla ne contient qu'une fois chaque organisme
	lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
	if {$Expect==0.0} { set Expect 1.0e-250 }
	#		if {$Expect >1.0} { set Expect 1.0 }
	set TaxId  [string trim $TaxId]
	set OS     [string trim $OS]
	set Reste  [string trim $Reste]
	if {[lsearch $LesOrganismesInteressants $TaxId]<0} { continue }	
	
	if {$PremierTaxId==""} { set PremierTaxId $TaxId }
	set Expect [string trim $Expect]
	set Score  [string trim $Score]
	if {$Expect > $Seuil} { break }
	lappend LesExpects $Expect
	lappend LesScores  $Score
	lappend LesChoisis "$Expect\t$Score\t$TaxId\t$OS\t$Reste"
    }
    if {$LesChoisis=={}} { return "" }
    
    if {$UseExp} {
	set LesValeurs $LesExpects
	set LesValeurs [StatisticsFromList $LesValeurs Iterate log10]                          ;#rR passage en log
    } else {
	set LesValeurs $LesScores
    }
    lassign [StatisticsFromList $LesValeurs] MoyenneBidon EcartType Min Max Somme NbValeurs
    set Moyenne [expr $Somme/[llength $LesOrganismesInteressants]]
    
    set LaSortie {}
    foreach Choisi $LesChoisis {
	lassign [split $Choisi "\t"] Expect Score TaxId
	if {$UseExp} {
	    set Valeur $Expect
	    set Valeur [expr log10($Valeur)]                                          ;#rR passage en log
	} else {
	    set Valeur $Score
	}
	set Delta [expr $Valeur-$Moyenne]
	set HitAvecDelta "$Delta\t$Choisi"
	if {$SelectMethod=="FirstOnly" && $TaxId!=$PremierTaxId} { continue }         ;#rR la on choisit de ne garder que le meilleur dans l'ordre du blast
	if {$UseExp} {
	    if {$SelectMethod=="BestOnly"     && $Delta > -10}   { continue }
	    if {$SelectMethod=="AboveAverage" && $Delta > 0}     { continue }
	} else {
	    if {$SelectMethod=="BestOnly"     && $Delta > 100}   { continue }
	    if {$SelectMethod=="AboveAverage" && $Delta > 0}     { continue }
	}
	lappend LaSortie $HitAvecDelta
    }
    
    if {[regexp "/" $GetWhat] || [string equal -nocase "Save" $GetWhat]} {
	set FichierDeltas $GetWhat
	if {[string equal -nocase "Save" $GetWhat]} { set FichierDeltas [GscopeFile $Nom delta] }
	return [SauveLesLignes $LaSortie dans $FichierDeltas]
    }
    if {[string equal -nocase "GetList" $GetWhat]} { return $LaSortie }
    if {[string equal -nocase "GetText" $GetWhat]} { return [join $LaSortie "\n"] }
    return [AfficheListe $LaSortie]
}

proc HistoDelta {{Clade ""} {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {
    if {$Clade==""} { set Clade [SelectClade]  }

    set EnTest [regexp {^(ripp|scherb)$} [Login]] 
    #	set EnTest 0

    if {$UseExpect==""}  { set UseExpect "UseScore" }
    set UseExp [string equal -nocase "UseExpect" $UseExpect]

    if {$GetWhat==""}    { set GetWhat "Show" }
    if {$Seuil==""}      { set Seuil 99999 }
    if {$Clade==""}      { set Clade [ReferenceClade] }
    regsub -all " " $Clade "_" CladeUnderscore
    
    set Echantillonage 100
    
    if {[OnTraite CiloCarta Like]} {
	set LesTaxIdsInteressants [QuestionDeScience CilioCarta "ret CladeContent $Clade"]
    } elseif {[OnTraite OI2017 Like]} {
	set LesTaxIdsInteressants [QuestionDeScience OI "ret CladeContentWithinOi2017 $Clade"]
    } else {
	FaireLire "Désolé. Il faut êrte CiloCarta LIke ou OI2017 Like"
    }
    if {[set i [lsearch $LesTaxIdsInteressants 9606]]>=0} {
	set LesTaxIdsInteressants [lreplace $LesTaxIdsInteressants $i $i]
    }
	
    set NbTaxId [llength $LesTaxIdsInteressants]
    
    foreach TaxId $LesTaxIdsInteressants {
	set SommeDesDeltasPour($TaxId) 0.0
	set NbDeltasPour($TaxId) 0
    }
    set LesMeilleurs {}
    set NbNom 0
    foreach Nom [ListeDesPABs] {
    	if {0 && $EnTest && $Nom > "HSAP20193"} { break }
	set LesHitsAvecDelta [LesHitsAvecDelta $Nom $LesTaxIdsInteressants $Seuil "GetList" $SelectMethod $UseExpect]
	if {1 && $NbNom%1000==0} { Espionne $Nom ; EspionneL $LesHitsAvecDelta }
	if {$LesHitsAvecDelta=={}} { continue }
	incr NbNom
	foreach HitAvecDelta $LesHitsAvecDelta {
	    lassign $HitAvecDelta Delta Expect Score TaxId OS Reste
	    regsub -all "\t" $OS " " OS

	    MemOlym $Nom-$TaxId Delta $Delta 
	    MemOlym $Nom-$TaxId Info  $HitAvecDelta 



	    set SommeDesDeltasPour($TaxId) [expr $SommeDesDeltasPour($TaxId)+$Delta]  ;#rR attention ici on additionne des carottes et des navets !!!!!!!! car Nom différents
	    set InfoDu($TaxId) "$OS\t$Reste"
	    incr NbDeltasPour($TaxId)
	    lappend LesDeltasDe($TaxId) $Delta
	    lappend LesNomsDe($TaxId,$Delta) $Nom
	    MemOlym $TaxId-$Delta ListOfNom $Nom
	    MemoDelta $TaxId $Delta $Nom
	    set BeauDelta [format "%6.0f" $Delta]
	    if {$Delta!=$BeauDelta} { MemOlym $TaxId-$BeauDelta ListOfNom $Nom ; MemoDelta $TaxId $Delta $Nom}
	}
    }
    foreach TaxId $LesTaxIdsInteressants {
	if {$NbDeltasPour($TaxId)==0} {
	    set Moyenne -999
	} else {
	    set Moyenne [expr $SommeDesDeltasPour($TaxId)/$NbDeltasPour($TaxId)]
	}
	set MoyenneDesDeltasPour($TaxId) $Moyenne
	lappend LesMoyennesDesDeltas $Moyenne
	lappend LesTaxIdsDeLaMoyenneDesDeltas($Moyenne) $TaxId
    }
    if {$UseExp} {
	set LesMoyennesDesDeltas [lsort -unique -real $LesMoyennesDesDeltas]
    } else {
	set LesMoyennesDesDeltas [lsort -decreasing -unique -real $LesMoyennesDesDeltas]
    }
    set LaSortie [list "# TailleP  NombreDeDelta  Moyenne    TaxId      Nom_de_l'espece "]
    foreach Moyenne $LesMoyennesDesDeltas {
	foreach TaxId $LesTaxIdsDeLaMoyenneDesDeltas($Moyenne) {
	    set BelleMoyenne [format "%6.0f" $Moyenne]
	    if { ! [info exists InfoDu($TaxId)]} { continue }
	    lappend LaSortie "[TailleProteome $TaxId]\t$NbDeltasPour($TaxId)\t$BelleMoyenne\t$TaxId\t$InfoDu($TaxId)\t$Moyenne"
	}
    }
    EspionneL $LaSortie
    set AvecHisto 0
    if {$AvecHisto} {
	set LargeurMax 4000
	set HauteurMax 5000
	set Largeur    3000
	set Hauteur    2000
	set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur]
	global BornesDuGraphe ; set BornesDuGraphe($K) [list -250 0 250 400]
    }
    
    set MinAllDelta  9999999
    set MaxAllDelta -9999999
    set IemeTaxId -1
    foreach TaxId $LesTaxIdsInteressants {
	if { ! [info exists LesDeltasDe($TaxId)]} { continue }
	set OS [Tax $TaxId Name]
	regsub -all " " $OS "_" OSUnderscore
	incr IemeTaxId
	
	set MinAllDelta  9999999
	set MaxAllDelta -9999999
	foreach Delta $LesDeltasDe($TaxId) {
	    set MinAllDelta [Mini $Delta $MinAllDelta]
	    set MaxAllDelta [Maxi $Delta $MaxAllDelta]
	}
    }
    set IntAllDelta [expr ($MaxAllDelta - $MinAllDelta)/$Echantillonage]

    set IemeTaxId -1
    foreach TaxId $LesTaxIdsInteressants {
	if { ! [info exists LesDeltasDe($TaxId)]} { continue }
	set OS [Tax $TaxId Name]
	regsub -all " " $OS "_" OSUnderscore
	incr IemeTaxId
	if {[info exists Cumul]} { unset Cumul }
	
	set MinDelta  9999999
	set MaxDelta -9999999
	foreach Delta $LesDeltasDe($TaxId) {
	    set MinDelta [Mini $Delta $MinDelta]
	    set MaxDelta [Maxi $Delta $MaxDelta]
	}
	set IntDelta [expr ($MaxDelta - $MinDelta)/$Echantillonage]
	
	set MinDeltaDe($TaxId) $MinDelta
	set MaxDeltaDe($TaxId) $MaxDelta
	set IntervalDeltaDe($TaxId) $IntDelta
	
	set MinCase  9999
	set MaxCase -9999
	foreach Delta $LesDeltasDe($TaxId) {
	    if {$IntDelta<0.0000001} {
		set Case 0
	    } else {
		#set Case [expr round(($Delta - $MinDelta)/$IntDelta)]
		set Case [expr round(($Delta - $MinAllDelta)/$IntAllDelta)]
	    }
	    set MinCase [Mini $MinCase $Case]
	    set MaxCase [Maxi $MaxCase $Case]
	    if { ! [info exists Cumul($Case)]} { set Cumul($Case) 0 }
	    incr Cumul($Case)
	    set Tag($Case) $Delta
	    foreach Nom [MemoDelta $TaxId $Delta] {
		set BeauDelta    [format "%6.0f" $Delta]
		set BelleMoyenne [format "%6.0f" $Moyenne]
		MemoInfo $TaxId $Case "$Nom [string trim $BeauDelta] $BelleMoyenne"
	    }
	}
	set LesX {}
	set LesY {}
	set LesTags {}
	set LaDistrib [list "#Delta      Nb       Case         TaxId           OS                                                                     Reference_Clade"]
	set LesBornesDeCases [NombresEntre $MinCase $MaxCase]
	if { ! $UseExp} {
	    set LesBornesDeCases [lreverse $LesBornesDeCases]
	}
	foreach Case $LesBornesDeCases {
	    if { ! [info exists Cumul($Case)]}         { set Cumul($Case) 0 }
	    if {$Cumul($Case)==0} { continue }
	    if { ! [info exists Tag($Case)]}           { set Tag($Case) "0.0" }
	    if { ! [info exists DeltaDeLaCase($Case)]} { set DeltaDeLaCase($Case) "0.0" }
	    set X  [expr $MinAllDelta + $Case*$IntAllDelta]
	    lappend LesX $X
	    lappend LesY $Cumul($Case)
	    lappend LesTags   "[format %6.0f $X]:$Cumul($Case) $OS"
	    lappend LaDistrib "[format %6.0f $X]\t$Cumul($Case)\t$Case\tTaxId:$TaxId\tOS:$OSUnderscore\tReferenceClade:$CladeUnderscore"  
	}
	MemoCase $TaxId LaDistrib $LaDistrib
	if {$AvecHisto} {
	    set Couleur [Nuance [expr 1.0*$IemeTaxId/$NbTaxId]]
	    Graphe $LesX $LesY $K $Couleur "" "" "" "" "HistoDelta" $LesTags "" "BindOnly_oval" $LargeurMax $HauteurMax
	} else {
	    #	    set F [AfficheListe $LaDistrib "AvecCase" $OS]
	    #	    set B [BoutonneLaFenetre $F "ShowHits" "ShowHitsFromTaxoBlast \[selection get\]"]
	    #	    $B configure -background "Magenta"
	}
    }	
	
    if {$GetWhat=="Show"} {
	set F [AfficheListe $LaSortie "" "Delta distribution for $Clade $Seuil $SelectMethod $UseExpect"]
	set B [BoutonneLaFenetre $F "Distribution" "ShowDeltaDistribution \[selection get\]"]
	$B configure -background "Magenta"
    }
    return $LaSortie
}

proc OlymPodium {K} {
    set Touche [$K find withtag current]
    set LesTags [$K gettags $Touche]
    lassign $LesTags Podium I J Clade Header
    if {[regexp {^[0-9]+\-[0-9]+$} $Header]} {
	set LesNoms [OlymStock "CaseRank-$Header" $Clade]
	foreach Nom $LesNoms {
	    set Id [ExtraitInfo $Nom Id]
	    set Ac [ExtraitInfo $Nom Ac]
	    set ValiGN [ExtraitInfo $Nom ValiGN]
	    lappend LesGn $ValiGN
	    set ValiDE [ExtraitInfo $Nom ValiDE]
	    lappend LaSortie "$Nom\t$Id\t$Ac\t$ValiGN\t$ValiDE"
	}
	set F [AfficheListe "#n°HSAP\n$LaSortie" "AvecFetch" "Hits with rank $Header for $Clade"]
	set GeneNames [join $LesGn ","]
	set B [BoutonneLaFenetre $F "GeneOntology" "GoGetShowFromGeneList $GeneNames"]
	$B configure -background "Magenta"
    }	
}

proc OlymMedals {} {
    set LesClades [OlymStock ListOf Clade]
    set LesTaxId  [OlymStock ListOf TaxId]
    set LesCasesRank [CaseRank ListOf]
    set LesHeaders {}
    set LesSensDuTri {}
    lappend LesHeaders    "Rank"         "RankAv"
    lappend LesSensDuTri  "0red-100blue" "0red-100blue"
    
    foreach Case $LesCasesRank {
	lappend LesHeaders $Case
	lappend LesSensDuTri "100red-0blue"
    }
    lappend LesHeaders   "Score"        "ScoreAv"      "Expect"       "ExpectAv"
    lappend LesSensDuTri "100red-0blue" "100red-0blue" "0red-100blue" "0red-100blue"
    foreach Clade $LesClades {
	set MoyRank       [OlymStock $Clade MoyenneRank]
	set MoyScore      [OlymStock $Clade MoyenneScore]
	set MoyExpect     [OlymStock $Clade MoyenneExpect]
	lappend LesCladesDuRank($MoyRank) $Clade 	
	lappend LesRanks $MoyRank	 	
    }
    set LesRanks [lsort -unique -integer $LesRanks]
    set LesCladesRankes {}
    foreach Rank $LesRanks {
	foreach Clade $LesCladesDuRank($Rank) {
	    lappend LesCladesRankes $Clade
	}
    }
    set I -1
    foreach Clade $LesCladesRankes {
	incr I	
	
	set MoyRank       [OlymStock $Clade MoyenneRank]
	set MoyRankGen    [OlymStock Moyenne MoyenneRank]

	set MoyScore      [OlymStock $Clade MoyenneScore]
	set MoyScoreGen   [OlymStock Moyenne MoyenneScore]

	set MoyExpect     [OlymStock $Clade MoyenneExpect]
	set FMoyExpect    [format "%4.2f" $MoyExpect]
	set MoyExpectGen  [OlymStock Moyenne MoyenneExpect]
	set FMoyExpectGen [format "%4.2f" $MoyExpectGen]

	
	set x -1
	set T($I,[incr x]) $MoyRank 
	set T($I,[incr x]) $MoyRankGen 
	foreach Case $LesCasesRank {
	    set LesNoms [OlymStock "CaseRank-$Case" $Clade]
	    set N [llength $LesNoms]
	    set T($I,[incr x]) $N
	}
	

	set T($I,[incr x]) $MoyScore	
	set T($I,[incr x]) $MoyScoreGen	
	set T($I,[incr x]) $FMoyExpect
	set T($I,[incr x]) $FMoyExpectGen		 	
    }	
    return [Medals $LesCladesRankes [array get T] $LesHeaders $LesSensDuTri]
}

proc Medals {{LesTitres ""} {LeT ""} {LesHeaders ""} {LesSensDuTri ""} {TagClick ""} {NomDe ""}} {
    #rR Medals affiche un tableau rectangulaire de lignes I et de colonnes J fournies par le array LeT
    #rR  en début de chaque ligne il y a un titre
    #rR  au dessus de chaque colonne il y a un header
    #rR Quand on clique sur un rectangle on exécute TagClick.
    if {$TagClick==""} { set TagClick "podium" }

    array set T $LeT
    set LesIJ [array names T]

    set LesI {}
    set LesJ {}
    foreach IJ $LesIJ {
	lassign [split $IJ ","] I J
	lappend LesI $I
	lappend LesJ $J
    }
    set LesI [lsort -integer -unique $LesI]
    set LesJ [lsort -integer -unique $LesJ]

    foreach I $LesI {
	foreach J $LesJ {
	    if { ! [info exists T($I,$J)]} { set T($I,$J) 0 }
	}
    }
    set MaxTitreSize -1
    foreach Titre $LesTitres {
	set MaxTitreSize [Maxi $MaxTitreSize [string length $Titre]]
    }

    set K [UnCanva "" 600 1600 600 1600]
    set CRed   0.1
    set CBlue  0.5
    set CSGx [expr $MaxTitreSize*8]
    set CSGy  50
    set W 50
    set Ex 5
    set H 20
    set Ey $Ex
    #set Tx 350
    #set Ty 80
    foreach Header $LesHeaders Sens $LesSensDuTri J $LesJ {
	set HeaderDe($J) $Header
	set SensDuTri($J) $Sens
	set Dx [expr $CSGx + $W*$J + $Ex*$J]
	set Fx [expr $Dx + $W]
	set Cx [expr ($Dx+$Fx)/2]
	if {[regexp {(^-?[0-9]+)\-(-?[0-9]+)$} $Header Match D S F]} { set Header $D }
	$K create text $Cx [expr $CSGy-20] -text $Header -anchor center
    }
    foreach J $LesJ {
	set Min 99999999
	set Max -99999999
	foreach I $LesI {
	    if {$T($I,$J)<$Min } {set Min $T($I,$J)}
	    if {$T($I,$J)>$Max } {set Max $T($I,$J)}
	}
	set ValeurMin($J) $Min
	set ValeurMax($J) $Max
    }	
    foreach Titre $LesTitres I $LesI {
	regsub -all " " $Titre "_" Titre
	set TitreDe($I) $Titre
	set Dy [expr $CSGy + $H*$I + $Ex*$I]
	set Fy [expr $Dy + $H]
	set Cy [expr ($Dy+$Fy)/2]
	$K create text 10 $Cy -text $Titre -anchor w -tags "clade $Titre" 
	foreach J $LesJ {
	    set Dx [expr $CSGx + $W*$J + $Ex*$J]
	    set Fx [expr $Dx + $W]
	    set Cx [expr ($Dx+$Fx)/2]
	    if {$SensDuTri($J)=="0red-100blue"} {
		set Cmin $CRed
		set Cmax $CBlue
	    } else {			
		set Cmin $CBlue
		set Cmax $CRed
	    }
	    if {($ValeurMax($J)-$ValeurMin($J))==0} { 
		set Couleur [Nuance 0.5 $Cmin $Cmax]
	    } else {
		set Couleur [Nuance [expr 1.0*($T($I,$J)-$ValeurMin($J))/($ValeurMax($J)-$ValeurMin($J))] $Cmin $Cmax]
	    }
	    $K create rectangle $Dx $Dy $Fx $Fy -fill $Couleur    -tags "$TagClick $I $J $TitreDe($I) $HeaderDe($J)"
	    $K create text $Cx $Cy -text $T($I,$J) -anchor center -tags "$TagClick $I $J $TitreDe($I) $HeaderDe($J)"
	    
	}
    }
    if {$TagClick=="podium"} {
	$K bind "podium" <1>       "OlymPodium       $K"
	$K bind "clade"  <1>       "RunBlastOutliers $K UseExpect"
	$K bind "clade"  <Shift-1> "RunBlastOutliers $K UseScore"
    } elseif {$TagClick=="zonard"} {
	lassign [split $] Clade 
	$K bind "zonard" <1>       "ShowZonards      $K $NomDe"
	$K bind "clade"  <1>       "RunDeltaDistributionForClade $K"
    } else {
	$K bind "Distri" <1>       "ShowDistriHits   $K"
	$K bind "clade"  <1>       "RunBlastOutliers $K UseExpect"
	$K bind "clade"  <Shift-1> "RunBlastOutliers $K UseScore"
    }
    return $K
}

proc ShowDistriHits K {
    set Touche [$K find withtag current]
    set LesTags [$K gettags $Touche]
    lassign $LesTags Distri I J Clade RepresentativeDelta
Espionne $LesTags
    set TaxId [MemoDistri $I ItsTaxId]
    set Box   [MemoDistri $RepresentativeDelta ItsBox]
Espionne "$TaxId=$Box="

    set LaSortie {}
    foreach Delta [MemoDistri $Box ListOfDelta] {
	set LesNoms [MemOlym $TaxId-$Delta ListOfNom]
Espionne "MemOlym $TaxId-$Delta ListOfNom"
Espionne $LesNoms
	foreach Nom $LesNoms {
	    set Id [ExtraitInfo $Nom Id]
	    set Ac [ExtraitInfo $Nom Ac]
	    set ValiGN [ExtraitInfo $Nom ValiGN]
	    lappend LesGn $ValiGN
	    set ValiDE [ExtraitInfo $Nom ValiDE]
	    lappend LaSortie "$Nom\t$Id\t$Ac\t$ValiGN\t$ValiDE"
	}
    }	
    set F [AfficheListe "#n°HSAP\n$LaSortie" "AvecFetch" "Hits with at least $Distri for $Clade"]
    set GeneNames [join $LesGn ","]
    set B [BoutonneLaFenetre $F "GeneOntology" "GoGetShowFromGeneList $GeneNames"]
    $B configure -background "Magenta"
}

proc RunBlastOutliers {K {UseExpect ""}} {
    set Id [$K find withtag current]Seuil
    set Clade [lindex [$K gettags $Id] 1]
    BlastOutliers $UseExpect $Clade
}

proc NearestColor {rgb} {
    set RGB [split $rgb " "]
    set r [lindex $RGB 0]
    set g [lindex $RGB 1]
    set b [lindex $RGB 2]
    set ListeRGB [Palette listof rgb ]
    set Dmin [expr 255*255*3]
    foreach RGB $ListeRGB {
	set x [lindex $RGB 0]
	set y [lindex $RGB 1]
	set z [lindex $RGB 2]
	set D2 [expr ($r-$x)**2 + ($g-$y)**2 + ($b-$z)**2 ]
	if {$D2<$Dmin} { set Dmin $D2; set NearestRGB $RGB}	
    }		
    return $NearestRGB
}

proc TousLesPremiersDuClade {Nom LesOrganismesInteressants {Seuil ""} {GetWhat ""}} {
    if {$GetWhat==""} { set GetWhat "Show" }
    if {$Seuil==""} { set Seuil 0.001 }

    set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]]
    if {$LesOrgaTrie=={}} { return "The file taxobla/$Nom does not exist" }
    set LaSortie {}
    foreach Ligne $LesOrgaTrie {
	lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
	set TaxId  [string trim $TaxId]
	set OS     [string trim $OS]
	set Reste  [string trim $Reste]
	if {[lsearch $LesOrganismesInteressants $TaxId]<0} { continue }	
	set Expect [string trim $Expect]
	if {$Expect > $Seuil} { break }
	lappend LaSortie $Ligne
    }
    if {$LaSortie=={}} { return "" }

    if {[regexp "/" $GetWhat] || [string equal -nocase "Save" $GetWhat]} {
	set FichierPremiers $GetWhat
	if {[string equal -nocase "Save" $GetWhat]} { set FichierPremiers [GscopeFile $Nom premier] }
	return [SauveLesLignes $LaSortie dans $FichierPremiers]
    }
    if {[string equal -nocase "GetList" $GetWhat]} { return $LaSortie }
    if {[string equal -nocase "GetText" $GetWhat]} { return [join $LaSortie "\n"] }
    return [AfficheListe $LaSortie]
}

proc HistoPremier {{Clade ""} {Seuil ""} {GetWhat ""}} {
    
    if {$GetWhat==""} { set GetWhat "Show" }
    if {$Seuil==""} { set Seuil 0.001 }
    if {$Clade==""} { set Clade [ReferenceClade] }

    if {[OnTraite CiloCarta Like]} {
	set LesTaxIdsInteressants [QuestionDeScience CilioCarta "ret CladeContent $Clade"]
    } elseif {[OnTraite OI2017 Like]} {
	set LesTaxIdsInteressants [QuestionDeScience OI "ret CladeContentWithinOi2017 $Clade"]
    } else {
	FaireLire "Désolé il faut être LioCarta Like ou OI2017 Like"
    }
    set LesMeilleurs {}
    set N 0
    foreach Nom [ListeDesPABs] {
	if {$N%100==0} { Espionne "$N $Nom" }
    	if {$Nom>"HSAP01000"} { break }
	set LesPremiers [TousLesPremiersDuClade $Nom $LesTaxIdsInteressants "" "GetList"]
	if {$LesPremiers=={}} { continue }
	incr N		
	set P [lindex $LesPremiers 0]
	lassign $P PN TaxId OS
	if { ! [info exists Cumul($TaxId)]}	{
	    set Cumul($TaxId) 0
	    lappend LesMeilleurs $TaxId
	} 
	incr Cumul($TaxId)
    }
    
    set LesMeilleurs [lsort -unique $LesMeilleurs]
    foreach Meilleur $LesMeilleurs {
	set C $Cumul($Meilleur)
	lappend LesCumularsDe($C) $Meilleur
    }
    set LesC [array names LesCumularsDe]
    set LesMeilleursTries {}
    foreach C [lsort -decreasing -integer $LesC] {
	LConcat LesMeilleursTries $LesCumularsDe($C)
    }
    foreach Meilleur $LesMeilleursTries {
	lappend LaSortie "$Cumul($Meilleur) $Meilleur [Tax $Meilleur Name]"
    }
    return $LaSortie
    EspionneL $LaSortie

    SauveLesLignes [array get LesCumularsDe] dans "/home/scherb/gscoperso/Cumulars.txt"

    
    set LesC {}
    foreach C [lsort -integer [array names LesCumularsDe]] {
	lappend LesC $C
	lappend LesNC [llength $LesCumularsDe($C)]
    }
    Espionne $LesC
    Espionne $LesNC
    return [Graphe $LesC $LesNC "" "" "" "" "" "" "Histogramme coucou"]

}

proc HistoPremierMemo {{FichierCumulars ""}} {

    if {$FichierCumulars=={}} { set FichierCumulars "/home/scherb/gscoperso/Cumulars.txt" }

    array set LesCumularsDe [LesLignesDuFichier $FichierCumulars]	
    parray LesCumularsDe
    
    set LesC {}
    foreach C [lsort -integer [array names LesCumularsDe]] {
	lappend LesC $C
	lappend LesNC [llength $LesCumularsDe($C)]
    }
    Espionne $LesC
    Espionne $LesNC
    return [Graphe $LesC $LesNC "" "" "" "" "" "" "Histogramme coucou"]

}

proc TailleProteome Qui {
    global TailleProteome

    if {[OnTraite "OI2017" "Like"]} {
	return [OiProteomeSize $Qui]
    }

    if {[info exists TailleProteome($Qui)]} { return $TailleProteome($Qui) }
    if {[info exists TailleProteome("EstCharge")]} { return -1 }
    set TailleProteome("EstCharge") 1
    
    set Fichier "[RepertoireDuGenome]/banques/Proteome201501_TaillesDesOs.txt"
    foreach Ligne [LesLignesDuFichier $Fichier]	{
	if { ! [regexp {^([0-9]+)[ \t].+_([0-9]+)} $Ligne Match Taille TaxId]} { continue }
	set TailleProteome($TaxId) $Taille
    }
    set TailleProteome(9606) 20193   ; #rR dans la banque il y en a 66922
                                       #rR on n'a gardé que les swissprot 
    

    return [TailleProteome $Qui]
}

proc TestMemoDelta {} {
    MemoDelta a b x
    MemoDelta a b y
    MemoDelta a b z

    Espionne [MemoDelta a b]
    Espionne [MemoDelta a r]

    MemoDelta Reset

    MemoDelta a b y
    MemoDelta a b z

    Espionne [MemoDelta a b]
    Espionne [MemoDelta a r]

}

proc MemoDelta {{Qui ""} {Quoi ""} {Valeur ""}} {
    global MemoDelta
    
    set Qui  [string trim $Qui]
    set Quoi [string trim $Quoi]

    if {$Qui=="Reset"} {
	if {[info exists MemoDelta]} { unset MemoDelta }
	return ""
    }
    
    if {$Valeur==""} {
	if {[info exists MemoDelta($Qui,$Quoi)]}  { return $MemoDelta($Qui,$Quoi) }
	if {[info exists MemoDelta("EstCHarge")]} { return "" }
    }
    set MemoDelta("EstCHarge") 1
    lappend MemoDelta($Qui,$Quoi) $Valeur
    return [MemoDelta $Qui $Quoi]
}

proc MemoInfo {{Qui ""} {Quoi ""} {Valeur ""}} {
    global MemoInfo
    
    set Qui  [string trim $Qui]
    set Quoi [string trim $Quoi]

    if {$Qui=="Reset"} {
	if {[info exists MemoInfo]} { unset MemoInfo }
	return ""
    }
    
    if {$Valeur==""} {
	if {[info exists MemoInfo($Qui,$Quoi)]}  { return $MemoInfo($Qui,$Quoi) }
	if {[info exists MemoInfo("EstCHarge")]} { return "" }
    }
    set MemoInfo("EstCHarge") 1
    lappend MemoInfo($Qui,$Quoi) $Valeur
    return [MemoInfo $Qui $Quoi]
}

proc MemoCase {{Qui ""} {Quoi ""} {Valeur ""}} {
    global MemoCase
    
    set Qui  [string trim $Qui]
    set Quoi [string trim $Quoi]
    if {$Qui=="Reset"} {
	if {[info exists MemoCase]} { unset MemoCase }
	return ""
    }
    
    if {$Valeur==""} {
	if {[info exists MemoCase($Qui,$Quoi)]}  { return $MemoCase($Qui,$Quoi) }
	if {[info exists MemoCase("EstCHarge")]} { return "" }
    }
    set MemoCase("EstCHarge") 1
    set MemoCase($Qui,$Quoi) $Valeur
    return [MemoCase $Qui $Quoi]
}

proc MemoDistri {{Qui ""} {Quoi ""} {Valeur ""}} {
    global MemoDistri
    
    set Qui  [string trim $Qui]
    set Quoi [string trim $Quoi]
    if {$Qui=="Reset"} {
	if {[info exists MemoDistri]} { unset MemoDistri }
	return ""
    }
    
    if {$Valeur==""} {
	if {[info exists MemoDistri($Qui,$Quoi)]}  { return $MemoDistri($Qui,$Quoi) }
	if {[info exists MemoDistri("EstCHarge")]} { return "" }
    }
    set MemoDistri("EstCHarge") 1
    lappend MemoDistri($Qui,$Quoi) $Valeur
    return [MemoDistri $Qui $Quoi]
}

proc BlastOutliers {{UseExpect ""} {Clade ""}} {
    return [HistoDelta $Clade "" Show "" $UseExpect]
}

proc ShowDeltaDistributionForClade {{Clade ""} {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {
    set LesLignes [HistoDelta $Clade $Seuil "GetList" $SelectMethod $UseExpect]
    set T(Min,Delta)  99999
    set T(Max,Delta) -99999
    foreach Ligne $LesLignes {
	if {[regexp "^#" $Ligne]} { continue }
	regsub -all {[ \t]+} $Ligne " " Ligne
	set LesMots [split [string trim $Ligne] " "]
	lassign $LesMots TailleProteome NbDelta Moyenne TaxId
	set OS [join [lrange $LesMots 4 end] " "]
	set T($TaxId,OS) $OS
	set LaDistrib [MemoCase $TaxId "LaDistrib"]
	lappend T(ListOf,TaxId) $TaxId
	set T($TaxId,MinDelta)  99999
	set T($TaxId,MaxDelta) -99999
	foreach Distri $LaDistrib {
	    if {[regexp "^#" $Distri]} { continue }
	    lassign [split $Distri "\t"] Delta Count Case tid o RefCla
	    regsub -all " " $Delta "" Delta
	    regsub -all " " $Count "" Count
	    regsub -all " " $Case  "" Case
	    regsub "ReferenceClade:" $RefCla "" ReferenceClade
	    Espionne "$Delta $Count $Case"
	    set T($TaxId,$Delta) $Count
	    set T($TaxId,MinDelta) [Mini $T($TaxId,MinDelta) $Delta]
	    set T($TaxId,MaxDelta) [Maxi $T($TaxId,MaxDelta) $Delta]
	    lappend T($Delta,ListOfTaxId) $TaxId
	    lappend T(ListOf,Delta) $Delta
	}
	set T(Min,Delta) [Mini $T(Min,Delta) $T($TaxId,MinDelta)] 
	set T(Max,Delta) [Maxi $T(Max,Delta) $T($TaxId,MaxDelta)] 
    }
    set UseExpect [string equal -nocase $UseExpect "UseExpect"]
    if {$UseExpect} {
	set T(ListOf,Delta) [lsort -integer -decreasing $T(ListOf,Delta)]
    } else {
	set T(ListOf,Delta) [lsort -integer -increasing $T(ListOf,Delta)]
    }
    set LesHeaders {}
    set Box 0
    set LesDelta $T(ListOf,Delta)
    set OnBreak 0
    while {1} {
	set N [llength $LesDelta]
	Espionne $LesDelta
	set Portion [expr $N/3]
	if {$N<12} {
	    set LesCourants $LesDelta
	    set OnBreak 1
	} else {
	    set PortionMoinsUn [expr $Portion-1]
	    set LesCourants [lrange $LesDelta end-$Portion end]
	    set LesDelta    [lrange $LesDelta 0            end-$PortionMoinsUn]
	}
	Espionne "Box $Box : $LesCourants"
	set BoxVide($Box) 1
	foreach D $LesCourants {
	    if {[info exists DejaVu($D)]} { continue }
	    set DejaVu($D) 1
	    foreach TaxId $T($D,ListOfTaxId) {
		set BoxVide($Box) 0
		set BM1 [expr $Box - 1]		
		if { ! [info exists CumulParBox($BM1,$TaxId)]} { set CumulParBox($BM1,$TaxId) 0 }
		if { ! [info exists CumulParBox($Box,$TaxId)]} { set CumulParBox($Box,$TaxId) $CumulParBox($BM1,$TaxId) }
		incr CumulParBox($Box,$TaxId) $T($TaxId,$D)
		Espionne "incr CumulParBox($Box,$TaxId) $T($TaxId,$D) > $CumulParBox($Box,$TaxId)"
	    }
	    MemoDistri $Box ListOfDelta $D 
	}
	if { ! $BoxVide($Box) } {
	    set Delta [lindex $LesCourants 0]
	    MemoDistri $Delta ItsBox $Box
	    lappend LesHeaders $Delta 
	}
	if {$OnBreak} { break }
	incr Box
    }
    set MaxBox $Box

    set I 0
    foreach TaxId $T(ListOf,TaxId) {
	set Box 0
	set LaLigne {}
	foreach Box [NombresEntre 0 $MaxBox] {
	    if {$BoxVide($Box)} { continue }
	    if { ! [info exists CumulParBox($Box,$TaxId)]} { set CumulParBox($Box,$TaxId) 0 }
	    lappend LaLigne [format "%7d" $CumulParBox($Box,$TaxId)]
	    set W($I,$Box) $CumulParBox($Box,$TaxId)
	    incr Box
	}
	Espionne "[format %-30s $T($TaxId,OS)] [join $LaLigne { }]" 
	lappend LesTitres $T($TaxId,OS)
	MemoDistri $I ItsTaxId $TaxId
	incr I
    }
    set NbBox [expr $MaxBox + 1]
    if {$UseExpect} {
	set LesSensDuTri [string repeat "100red-0blue" $NbBox]
    } else {
	set LesSensDuTri [string repeat "0blue-100red" $NbBox]
    }
    set LeW [array get W]
    return [Medals $LesTitres $LeW $LesHeaders $LesSensDuTri "Distri"]
} 
				     

proc ShowDeltaDistribution {Selection} {
    
    set LesFenetres {}
    foreach Sel [split $Selection "\n"] {
	if {[regexp "^#" $Sel]} { continue }
	regsub -all {[ \t]+} $Sel " " Sel
	set Sel [string trim $Sel]
	set TaxId [lindex [split $Sel " "] 3]
	set LaDistrib [MemoCase $TaxId "LaDistrib"]
	if {$LaDistrib==""} { continue }
	regsub -all {[ \t]+} $Sel " " SelPourTitre
	set F [AfficheListe $LaDistrib "AvecCase" "Delta distribution concerning $SelPourTitre"]
	set B [BoutonneLaFenetre $F "ShowHits" "ShowHitsFromTaxoBlast \[selection get\]"]
	$B configure -background "Magenta"
	lappend LesFenetres $F
    }
    return $LesFenetres
}

proc ShowHitsFromTaxoBlast {Selection} {
    
    set LaSortie [list "#[PreFixe]  EcartMoy   Moyenne  Id                 VaLign          Valide                                                 NumeroDuTaxId                                              OS                                      Reference"]                                                                                                                                                   
    set LesGn    {}
    foreach Sel [split $Selection "\n"] {
	if {[regexp "^#" $Sel]} { continue }
	regsub -all {[ \t]+} $Sel " " Sel
	lassign [split [string trim $Sel] " "] Delta N Case
	
	set TaxId [StringApres "TaxId:"          dans $Sel]
	set OS    [StringApres "OS:"             dans $Sel]
	set Clade [StringApres "ReferenceClade:" dans $Sel]
	
	set LesAccess {}
	foreach Info [MemoInfo $TaxId $Case] {
	    scan $Info "%s" Nom
	    set Id [ExtraitInfo $Nom Id]
	    set Ac [ExtraitInfo $Nom Ac]
	    set ValiGN [ExtraitInfo $Nom ValiGN]
	    lappend LesGn $ValiGN
	    set ValiDE [ExtraitInfo $Nom ValiDE]
	    lappend LaSortie $Info\t$Id\t$Ac\t$ValiGN\t$ValiDE\tTaxId:$TaxId\tOS:$OS\tReferenceClade:$Clade
	}
    }
    set LaSortie [lsort -unique $LaSortie]
    set GeneNames [join $LesGn ","]
    set F [AfficheListe $LaSortie "" "$TaxId [TaxClass $TaxId Name Reverse]"]
    set B [BoutonneLaFenetre $F "GeneOntology" "GoGetShowFromGeneList $GeneNames"]
    $B configure -background "Magenta"
    set B [BoutonneLaFenetre $F "Outliers" "OutliersFromSelection \[selection get\]"]
    $B configure -background "Magenta"
    return $F   
}

proc OutliersFromSelection Selection {
    foreach Sel [split $Selection "\n"] {
	if {[regexp "^#" $Sel]} { continue }
	scan $Sel "%s" Nom
	set TaxId [StringApres "TaxId:"          dans $Sel]
	set OS    [StringApres "OS:"             dans $Sel]
	set Clade [StringApres "ReferenceClade:" dans $Sel]
	set Seuil ""
	lappend LesFenetres [OutlierOrganismInBlast $Nom $TaxId $Clade $Seuil "Show"]
    }
    return $LesFenetres
}

proc GoGetShowFromGeneListWithNom LesNoms {
    set Noms [join $LesGn ","]
    set LesGnGO [GoGetFromGeneList $GeneNames "GOacc,name" "" "\t"]
    foreach GnGO $LesGnGO {
	if {[regexp {^([^=]+)=(.*)$} $GnGO Match Gn GOsPropres]} {
	    set GOs $GOsPropres
	    lappend LesGenesEtLeursGOs "\n$Gn *************"
	}
	foreach GO [split $GOs "\t"] {
	    lassign $GO GoAcc GoName
	    lappend LesGoAcc  $GoAcc
	    lappend LesGoName $GoName
	    set GoAccName "$GoAcc $GoName"
	    lappend LesGenesEtLeursGOs "$Gn $GoAccName"
	    lappend LesGenesDu($GoAccName) $Gn
	    set LesGenesDu($GoAccName) [lsort -unique $LesGenesDu($GoAccName)]
	}
    }
    set LesNombres {}
    set LesGOsEtLeursGenes [list "#GeneCount GO                                     Genes"]
    foreach {GoAccName Genes} [array get LesGenesDu] {
	set Nombre [llength $Genes]
	lappend LesNombres $Nombre
	lappend LesGoDeLaLongueur($Nombre) $GoAccName
    }
    set LesNombres [lsort -integer -unique -decreasing $LesNombres]
    foreach Nombre $LesNombres {
	foreach GoAccName $LesGoDeLaLongueur($Nombre) {
	    lappend LesGOsEtLeursGenes " $Nombre $GoAccName"
	    set Genes [join $LesGenesDu($GoAccName)	" "]			
	    set TexteAAfficher $Genes
	    while {[string length $TexteAAfficher]>80} {
		set Debut          [string range $TexteAAfficher 0 79]			
		set iDBlanc        [string last " " $Debut]
		set BonDebut       [string range $TexteAAfficher 0          $iDBlanc-1]
		set TexteAAfficher [string range $TexteAAfficher $iDBlanc+1 end]
		lappend LesGOsEtLeursGenes "[string repeat { } 40] $BonDebut"
	    }
	    if {$TexteAAfficher != ""} {
		lappend LesGOsEtLeursGenes "[string repeat { } 40] $TexteAAfficher"
	    }
	}
    }	
    set LesFenetres {}
    #set F [AfficheListe $LesGenesEtLeursGOs "GrandeLargeur" "Genes With their GOs"]
    lappend LesFenetres [AfficheListe $LesGOsEtLeursGenes "GrandeLargeur" "GOs with their genes"]
    return $LesFenetres
}

proc GoGetShowFromGeneList LesGn {
    set GeneNames [join $LesGn ","]
    set LesGnGO [GoGetFromGeneList $GeneNames "GOacc,name" "" "\t"]
    foreach GnGO $LesGnGO {
	if {[regexp {^([^=]+)=(.*)$} $GnGO Match Gn GOsPropres]} {
	    set GOs $GOsPropres
	    lappend LesGenesEtLeursGOs "\n$Gn *************"
	}
	foreach GO [split $GOs "\t"] {
	    lassign $GO GoAcc GoName
	    lappend LesGoAcc  $GoAcc
	    lappend LesGoName $GoName
	    set GoAccName "$GoAcc $GoName"
	    lappend LesGenesEtLeursGOs "$Gn $GoAccName"
	    lappend LesGenesDu($GoAccName) $Gn
	    set LesGenesDu($GoAccName) [lsort -unique $LesGenesDu($GoAccName)]
	}
    }
    set LesNombres {}
    set LesGOsEtLeursGenes [list "#GeneCount GO                                     Genes"]
    foreach {GoAccName Genes} [array get LesGenesDu] {
	set Nombre [llength $Genes]
	lappend LesNombres $Nombre
	lappend LesGoDeLaLongueur($Nombre) $GoAccName
    }
    set LesNombres [lsort -integer -unique -decreasing $LesNombres]
    foreach Nombre $LesNombres {
	foreach GoAccName $LesGoDeLaLongueur($Nombre) {
	    lappend LesGOsEtLeursGenes " $Nombre $GoAccName"
	    set Genes [join $LesGenesDu($GoAccName)	" "]			
	    set TexteAAfficher $Genes
	    while {[string length $TexteAAfficher]>80} {
		set Debut          [string range $TexteAAfficher 0 79]			
		set iDBlanc        [string last " " $Debut]
		set BonDebut       [string range $TexteAAfficher 0          $iDBlanc-1]
		set TexteAAfficher [string range $TexteAAfficher $iDBlanc+1 end]
		lappend LesGOsEtLeursGenes "[string repeat { } 40] $BonDebut"
	    }
	    if {$TexteAAfficher != ""} {
		lappend LesGOsEtLeursGenes "[string repeat { } 40] $TexteAAfficher"
	    }
	}
    }	
    set LesFenetres {}
    #set F [AfficheListe $LesGenesEtLeursGOs "GrandeLargeur" "Genes With their GOs"]
    lappend LesFenetres [AfficheListe $LesGOsEtLeursGenes "GrandeLargeur" "GOs with their genes"]
    return $LesFenetres
}

proc LesNomsPourOlymClade {} {
    set LesNoms [ListeDesPABs]
#    set LesNoms [lrange $LesNoms 0 999]
    return $LesNoms
}

proc ChallengingClades {{Qui ""} {Quoi ""}} {
    #rR Connait les TaxIds des clades et le clade des TaxIds
    global ChallengingClades
    
    set LesClades {}
    if {$Qui=="Load"} {
	if {[info exists ChallengingClades]} { unset ChallengingClades }
	set LesClades $Quoi
	set Qui  "ListOf"
	set Quoi "Clade"
    }
    if {[info exists ChallengingClades($Qui,$Quoi)]}  { return $ChallengingClades($Qui,$Quoi) }
    if {[info exists ChallengingClades("EstCharge")]} { return "" }
    set ChallengingClades("EstCharge") 1
    
    if {$LesClades=={}} { set LesClades [SelectClade "Multiple"] }
    
    set ChallengingClades(ListOf,Clade) {}
    set ChallengingClades(ListOf,TaxId) {}
    foreach Clade $LesClades {
	Espionne $Clade
	lappend ChallengingClades(ListOf,Clade) $Clade
	if {[OnTraite "CilioCarta" "Like"]} {
	    set LesTaxIdsDuClade [QuestionDeScience CilioCarta "ret CladeContent $Clade"]
	} elseif {[OnTraite "OI2017" "Like"]}  {
#	    set LesTaxIdsDuClade [QuestionDeScience OI "ret CladeContentWithinOi2017 $Clade"]
	    set LesTaxIdsDuClade [CladeContentWithinOi2017 $Clade]
	    Espionne "CladeContentWithinOi2017 $Clade"
	    Espionne "LesTaxIdsDuClade $Clade = $LesTaxIdsDuClade"
	}
	if {[set i [lsearch $LesTaxIdsDuClade [NotreOX]]]>=0} {
	    set LesTaxIdsDuClade [lreplace $LesTaxIdsDuClade $i $i]
	}
	set ChallengingClades($Clade,Content) $LesTaxIdsDuClade
	LConcat ChallengingClades(ListOf,TaxId) $LesTaxIdsDuClade
	foreach TaxId $LesTaxIdsDuClade {
	    set ChallengingClades($TaxId,Clade) $Clade
	}
	Espionne $LesTaxIdsDuClade
    }
    return [ChallengingClades $Qui $Quoi]
}

proc OlymStock {{Qui ""} {Quoi ""} {Valeur ""}} {
    global OlymStock
    if {$Valeur==""} {
	if {[info exists OlymStock($Qui,$Quoi)]} { return $OlymStock($Qui,$Quoi) }
	if { ! [info exists OlymStock]} {
	    OlymClade                          ; #rR c'est là qu'on range tout !
	    return [OlymStock $Qui $Quoi]
	}
	if {[info exists OlymStock(EstCharge)]} { return "" }
    }
    if {$Qui=="CalculateAll"} {
	set OlymStock($Qui,EstCharge) 1
	set OlymStock(ListOf,Clade) [lsort -unique $OlymStock(ListOf,Clade)]
	foreach Clade $OlymStock(ListOf,Clade) {
	    set SommeExpect 0 
	    set SommeScore  0
	    set SommeRank   0
	    set NbNom 0
	    foreach Nom [LesNomsPourOlymClade] {
		if { ! [info exists OlymStock($Nom,$Clade-MoyenneExpect)]} { continue }
		incr NbNom
		set SommeExpect [expr $SommeExpect + $OlymStock($Nom,$Clade-MoyenneExpect)]
		set SommeScore  [expr $SommeScore  + $OlymStock($Nom,$Clade-MoyenneScore)]
		set SommeRank   [expr $SommeRank   + $OlymStock($Nom,$Clade-MoyenneRank)]
	    }
	    if {$NbNom==0} { continue }
	    set MoyenneExpect [expr $SommeExpect/$NbNom]
	    set MoyenneScore  [expr $SommeScore/$NbNom]
	    set MoyenneRank   [expr $SommeRank/$NbNom]
	    set OlymStock($Clade,NbNom)         $NbNom
	    set OlymStock($Clade,MoyenneExpect) $MoyenneExpect
	    set OlymStock($Clade,MoyenneScore)  $MoyenneScore
	    set OlymStock($Clade,MoyenneRank)   $MoyenneRank
	}
	set SommeMoyenneExpect 0
	set SommeMoyenneScore  0
	set SommeMoyenneRank   0
	set NbClade 0
	foreach Clade $OlymStock(ListOf,Clade) {
	    if { ! [info exists OlymStock($Clade,MoyenneExpect)]} { continue } 
	    incr NbClade
	    set SommeMoyenneExpect [expr $SommeMoyenneExpect + $OlymStock($Clade,MoyenneExpect)]
	    set SommeMoyenneScore  [expr $SommeMoyenneScore  + $OlymStock($Clade,MoyenneScore)]
	    set SommeMoyenneRank   [expr $SommeMoyenneRank   + $OlymStock($Clade,MoyenneRank)]
	}
	if {$NbClade==0} { parray OlymStock }
	set MoyenneMoyenneExpect [expr $SommeMoyenneExpect/$NbClade]
	set MoyenneMoyenneScore  [expr $SommeMoyenneScore/$NbClade]
	set MoyenneMoyenneRank   [expr $SommeMoyenneRank/$NbClade]
	OlymStock Moyenne MoyenneExpect $MoyenneMoyenneExpect
	OlymStock Moyenne MoyenneScore  $MoyenneMoyenneScore
	OlymStock Moyenne MoyenneRank   $MoyenneMoyenneRank
	#rR on en fait quoi ???
	
	set OlymStock(EstCharge) 1
    }
    lappend OlymStock($Qui,$Quoi) $Valeur  ; #rR attention on fait toujours lappend
    return $OlymStock($Qui,$Quoi)
}

proc CaseRank Valeur {
    global CaseRank
    if { ! [info exists CaseRank]} {
#	set CaseRank(Deb) [list 0 20 40 60 80 100] 
	set Pas 1
	set Pos 0
	while {1} {
	    if {$Pos>17} { break }
	    lappend CaseRank(Deb) $Pos
	    incr Pos $Pas
	}
	set CaseRank(Deb) 
	set CaseRank(Fin) [lrange $CaseRank(Deb) 1 end]
	lappend CaseRank(Fin) 100

	foreach D $CaseRank(Deb) F $CaseRank(Fin) {
	    lappend CaseRank(ListOf) "$D-$F"
	}
    }

    if {[info exists  CaseRank($Valeur)]} { return $CaseRank($Valeur) }

    foreach D $CaseRank(Deb) F $CaseRank(Fin) {
	if {$D <= $Valeur && $Valeur <= $F} { return "$D-$F" }
    }
    return ""
}

proc OlymClade {{Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""} {Clades ""}} {
    #rR On veut faire un classemnent des clades en fonction du comportement des 20000 blast par rapport au projet courant (initalement Homo sapiens)
    #rR OlymClade ne fait que remplir le tableau OlymStock puis lance les calculs par OlymStock CalculateAll
    if {$Clades!=""} { ChallengingClades "Load" $Clades }
    if {$UseExpect==""}    { set UseExpect    "UseExpect" }	
    if {$SelectMethod==""} { set SelectMethod "FirstOnly" }	
    if {$GetWhat==""}      { set GetWhat      "Show" }
    if {$Seuil==""}        { set Seuil        99999 }
    set iNom 0
    foreach Nom [LesNomsPourOlymClade] {
	set FiTaxobla [GscopeFile $Nom taxobla]
	if {[FileAbsent $FiTaxobla]} { continue }
	set LesCladesDuNom {}
	if {[info exists SommeExpect]} { unset SommeExpect }
	if {[info exists SommeScore]}  { unset SommeScore }
	set LesLignes [LesLignesDuFichier $FiTaxobla]
	set NbHitDuNom [llength $LesLignes]
	if {$NbHitDuNom==0} { continue }
	OlymStock $Nom NbHits $NbHitDuNom
	set iLigne 0 
	if {[info exists DejaVuCeClade]} { unset DejaVuCeClade }
	foreach Ligne $LesLignes {
	    incr iLigne
	    set Rank [expr round(100*$iLigne/$NbHitDuNom)]
	    lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
	    if {$Expect==0.0} { set Expect 1.0e-250 }
	    #		if {$Expect >1.0} { set Expect 1.0 }
	    set TaxId  [string trim $TaxId]
	    set OS     [string trim $OS]
	    set Reste  [string trim $Reste]
	    if {[set Clade [ChallengingClades $TaxId Clade]]==""} { continue } ;#rR on ne s'interesse qu'aux TaxIds qui sont dans un Clade participant	
	    if {[info exists DejaVuCeClade($Clade)]} { continue }
	    set DejaVuCeClade($Clade) 1
	    lappend LesCladesDuNom $Clade

	    set Rank [llength [array names DejaVuCeClade]]      ;#rR attention on triche a fond !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

	    OlymStock ListOf Clade   $Clade
	    OlymStock ListOf TaxId   $TaxId
	    OlymStock $Clade Content $TaxId

	    set Expect [string trim $Expect]
	    set Score  [string trim $Score]
	    set Score  [expr round($Score)]
	    if {$Expect > $Seuil} { break }

	    set Expect [expr log10($Expect)]        ; #rR attention on prend le log !!!!!!!!
	    lappend LesExpects $Expect
	    lappend LesScores  $Score
	    lappend LesRanks   $Rank
	    OlymStock $TaxId Expect$Nom $Expect 
	    OlymStock $TaxId Score$Nom  $Score 
	    OlymStock $TaxId Rank$Nom   $Rank 
	    lappend LesChoisis "$Expect\t$Score\t$TaxId\t$OS\t$Reste"

	    if { ! [info exists SommeExpect($Clade)]} { set SommeExpect($Clade) 0 }
	    if { ! [info exists SommeScore($Clade)]}  { set SommeScore($Clade) 0 }
	    if { ! [info exists SommeRank($Clade)]}   { set SommeRank($Clade) 0 }

	    set SommeExpect($Clade) [expr $SommeExpect($Clade) + $Expect]
	    set SommeScore($Clade)  [expr $SommeScore($Clade)  + $Score]
	    set SommeRank($Clade)   [expr $SommeRank($Clade)   + $Rank]
	    if { ! [info exists NbHitDuClade($Clade)]} { set NbHitDuClade($Clade) 0 }
	    incr NbHitDuClade($Clade) 
	}
	set LesCladesDuNom [ListeSansDoublon $LesCladesDuNom]
	set SommeMoyennesExpect 0
	set SommeMoyennesScore  0
	set SommeMoyennesRank   0
	foreach Clade $LesCladesDuNom {
	    set MoyenneExpect($Clade) [expr $SommeExpect($Clade)/$NbHitDuClade($Clade)]
	    set MoyenneScore($Clade)  [expr $SommeScore($Clade)/$NbHitDuClade($Clade)]
	    set MoyenneRank($Clade)   [expr $SommeRank($Clade)/$NbHitDuClade($Clade)]
	    OlymStock $Nom $Clade-MoyenneExpect $MoyenneExpect($Clade)
	    OlymStock $Nom $Clade-MoyenneScore  $MoyenneScore($Clade)
	    OlymStock $Nom $Clade-MoyenneRank   $MoyenneRank($Clade)
	    set SommeMoyennesExpect [expr $SommeMoyennesExpect + $MoyenneExpect($Clade)]
	    set SommeMoyennesScore  [expr $SommeMoyennesScore  + $MoyenneScore($Clade)]
	    set SommeMoyennesRank   [expr $SommeMoyennesRank   + $MoyenneRank($Clade)]

	    set Case [CaseRank $MoyenneRank($Clade)]
	    OlymStock ListOf CaseRank $Case 
	    OlymStock "CaseRank-$Case" $Clade $Nom
	}
	set NbCladesDuNom [llength $LesCladesDuNom]
	if {$NbCladesDuNom==0} { continue }
	OlymStock $Nom ListOfClade $LesCladesDuNom
	set MoyennesExpect [expr $SommeMoyennesExpect/$NbCladesDuNom]
	set MoyennesScore  [expr $SommeMoyennesScore/$NbCladesDuNom]
	set MoyennesRank   [expr $SommeMoyennesRank/$NbCladesDuNom]
	OlymStock $Nom MoyennesExpect $MoyennesExpect
	OlymStock $Nom MoyennesScore  $MoyennesScore
	OlymStock $Nom MoyennesRank   $MoyennesRank


	foreach Clade $LesCladesDuNom {
	    OlymStock $Nom $Clade-DeltaExpect [expr $MoyenneExpect($Clade)- $MoyennesExpect]
	    OlymStock $Nom $Clade-DeltaScore  [expr $MoyenneScore($Clade) - $MoyennesScore]
	    OlymStock $Nom $Clade-DeltaRank   [expr $MoyenneRank($Clade)  - $MoyennesRank]
	    #rR c'est ici qu'il faut les ranger dans des cases (on va peut-etre commencer par seulement les rank ...)
	}
    }
    OlymStock CalculateAll
}

proc TestMoyenneRank {} {
    set LesClades [OlymStock ListOf Clade]
    #    set LesClades [list Deuterostomia Fungi]
    foreach Nom [ListeDesPABs] {
	foreach Clade $LesClades {
	    set M [OlymStock $Nom $Clade-MoyenneRank]
	    Espionne "$Nom $M $Clade"
	}
    }
}

proc CladeChallenge {{Challenger ""} {Referencer ""} {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {
    FaireLire "Pas encore fini ... on voudrait comparer deux clades .. le meilleur de l'un par rapport à l'autre ???"
    if {$Challenger==""} { set Challenger [SelectOneClade]  }
    if {$Referencer==""}  { set Referencer [SelectOneClade]  }
    
    set EnTest [regexp {^(ripp|scherb)$} [Login]] 
    #	set EnTest 0
    
    if {$UseExpect==""}    { set UseExpect "UseScore" }	
    if {$GetWhat==""} { set GetWhat "Show" }
    if {$Seuil==""} { set Seuil 99999 }
    
    regsub -all " " $Challenger "_" ChallengerUnderscore
    regsub -all " " $Referencer "_" ReferencerUnderscore
    set UseExpect [string equal -nocase "UseExpect" $UseExpect]
    
    set Echantillonage 20
    
    if {[OnTraite CilioCarta Like]} {
	set LesTaxIdsChallenger [QuestionDeScience CilioCarta "ret CladeContent $Challenger"]
	set LesTaxIdsReferencer [QuestionDeScience CilioCarta "ret CladeContent $Referencer"]
    } elseif {[OnTraite OI2017 Like]} {
	set LesTaxIdsChallenger [QuestionDeScience OI "ret CladeContentWithinOi2017 $Challenger"]
	set LesTaxIdsReferencer [QuestionDeScience OI "ret CladeContentWithinOI2017 $Referencer"]
    } else {
    }
    set NbTaxIdChallenger [llength $LesTaxIdsChallenger]
    set NbTaxIdReferencer [llength $LesTaxIdsReferencer]
    
    # on fait l'initialisation
    foreach TaxId $LesTaxIdsReferencer {
	set SommeDesDeltasReferencerPour($TaxId) 0.0
	set NbDeltasReferencerPour($TaxId) 0
    }
    
    set LesMeilleursChallenger {}
    set LesMeilleursReferencer {}
    set NbNomChallenger 0
    set NbNomReferencer 0
    foreach Nom [ListeDesPABs] {
	if {0 && $NbNom%100==0} { Espionne "$NbNom $Nom" }
    	if {$EnTest && $Nom>"HSAP20193"} { break }
	set LesHitsAvecDeltaChallenger [LesHitsAvecDelta $Nom $LesTaxIdsChallenger $Seuil "GetList" $SelectMethod $UseExpect]
	set LesHitsAvecDeltaReferencer [LesHitsAvecDelta $Nom $LesTaxIdsReferencer $Seuil "GetList" $SelectMethod $UseExpect]
	if {$LesHitsAvecDeltaChallenger!={}} {
	    incr NbNomChallenger
	    foreach HitAvecDelta $LesHitsAvecDeltaChallenger {
		lassign $HitAvecDelta Delta Expect Score TaxId OS Reste
		regsub -all "\t" $OS " " OS
		set SommeDesDeltasChallengerPour($TaxId) [expr $SommeDesDeltasChallengerPour($TaxId)+$Delta]
		set InfoDu($TaxId) "$OS\t$Reste"
		incr NbDeltasChallengerPour($TaxId)
		lappend LesDeltasChallengerDe($TaxId) $Delta
		lappend LesNomsChallengerDe($TaxId,$Delta) $Nom
		MemoDelta $TaxId $Delta $Nom
	    }
	}
	if {$LesHitsAvecDeltaReferencer!={}} {
	    incr NbNomReferencer
	    foreach HitAvecDelta $LesHitsAvecDeltaReferencer {
		lassign $HitAvecDelta Delta Expect Score TaxId OS Reste
		regsub -all "\t" $OS " " OS
		set SommeDesDeltasReferencerPour($TaxId) [expr $SommeDesDeltasReferencerPour($TaxId)+$Delta]
		set InfoDu($TaxId) "$OS\t$Reste"
		incr NbDeltasReferencerPour($TaxId)
		lappend LesDeltasReferencerDe($TaxId) $Delta
		lappend LesNomsReferencerDe($TaxId,$Delta) $Nom
		MemoDelta $TaxId $Delta $Nom
	    }
	}
    }
    foreach TaxId $LesTaxIdsChallenger {
	set Moyenne [expr $SommeDesDeltasChallengerPour($TaxId)/$NbDeltasChallengerPour($TaxId)]
	set MoyenneDesDeltasChallengerPour($TaxId) $Moyenne
	lappend LesMoyennesDesDeltasChallenger $Moyenne
	lappend LesTaxIdsDeLaMoyenneDesDeltasChallenger($Moyenne) $TaxId
    }
    foreach TaxId $LesTaxIdsReferencer {
	set Moyenne [expr $SommeDesDeltasReferencerPour($TaxId)/$NbDeltasReferencerPour($TaxId)]
	set MoyenneDesDeltasReferencerPour($TaxId) $Moyenne
	lappend LesMoyennesDesDeltasReferencer $Moyenne
	lappend LesTaxIdsDeLaMoyenneDesDeltasReferencer($Moyenne) $TaxId
    }
    if {$UseExpect} {
	set LesMoyennesDesDeltasChallenger [lsort -unique -real $LesMoyennesDesDeltasChallenger]
	set LesMoyennesDesDeltasReferencer [lsort -unique -real $LesMoyennesDesDeltasChallenger]
    } else {
	set LesMoyennesDesDeltasChallenger [lsort -decreasing -unique -real $LesMoyennesDesDeltasChallenger]
	set LesMoyennesDesDeltasReferencer [lsort -decreasing -unique -real $LesMoyennesDesDeltasReferencer]
    }
    #####################################################################################################################
    set LaSortie [list "# TailleP  NombreDeDelta  Moyenne    TaxId      Nom_de_l'espece "]
    foreach Moyenne $LesMoyennesDesDeltasChallenger {
	foreach TaxId $LesTaxIdsDeLaMoyenneDesDeltasChallenger($Moyenne) {
	    set BelleMoyenne [format "%6.0f" $Moyenne]
	    lappend LaSortie "[TailleProteome $TaxId]\t$NbDeltasPourChallenger($TaxId)\t$BelleMoyenne\t$TaxId\t$InfoDu($TaxId)"
	}
    }
    set AvecHisto 0
    if {$AvecHisto} {
	set LargeurMax 4000
	set HauteurMax 5000
	set Largeur    3000
	set Hauteur    2000
	set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur]
	global BornesDuGraphe ; set BornesDuGraphe($K) [list -250 0 250 400]
    }
    set IemeTaxId -1
    
    foreach TaxId $LesTaxIdsChalenger {
	set OS [Tax $TaxId Name]
	regsub -all " " $OS "_" OSUnderscore
	incr IemeTaxId
	if {[info exists Cumul]} { unset Cumul }
	
	set MinDelta  9999999
	set MaxDelta -9999999
	foreach Delta $LesDeltasDeChallenger($TaxId) {
	    set MinDelta [Mini $Delta $MinDelta]
	    set MaxDelta [Maxi $Delta $MaxDelta]
	}
	set IntDelta [expr ($MaxDelta - $MinDelta)/$Echantillonage]
	
	set MinDeltaDe($TaxId) $MinDelta
	set MaxDeltaDe($TaxId) $MaxDelta
	set IntervalDeltaDe($TaxId) $IntDelta
	
	set MinCase  9999
	set MaxCase -9999
	foreach Delta $LesDeltasDe($TaxId) {
	    if {$IntDelta<0.0000001} {
		set Case 0
	    } else {
		set Case [expr round(($Delta - $MinDelta)/$IntDelta)]
	    }
	    set MinCase [Mini $MinCase $Case]
	    set MaxCase [Maxi $MaxCase $Case]
	    if { ! [info exists Cumul($Case)]} { set Cumul($Case) 0 }
	    incr Cumul($Case)
	    set Tag($Case) $Delta
	    foreach Nom [MemoDelta $TaxId $Delta] {
		set BeauDelta    [format "%6.0f" $Delta]
		set BelleMoyenne [format "%6.0f" $Moyenne]
		MemoInfo $TaxId $Case "$Nom $BeauDelta $BelleMoyenne"
	    }
	}
	set LesX {}
	set LesY {}
	set LesTags {}
	set LaCase [list "#EcartM      NF       Case         TaxId           OS                                                                     Reference_Clade"]
	set LesBornesDeCases [NombresEntre $MinCase $MaxCase]
	if { ! $UseExpect} {
	    set LesBornesDeCases [lreverse $LesBornesDeCases]
	}
	foreach Case $LesBornesDeCases {
	    if { ! [info exists Cumul($Case)]}         { continue }
	    if { ! [info exists Tag($Case)]}           { set Tag($Case) "0.0" }
	    if { ! [info exists DeltaDeLaCase($Case)]} { set DeltaDeLaCase($Case) "0.0" }
	    set X  [expr $MinDelta + $Case*$IntDelta]
	    lappend LesX $X
	    lappend LesY $Cumul($Case)
	    lappend LesTags "[format %5.0f $X]:$Cumul($Case) $OS"
	    lappend LaCase  "[format %5.0f $X]\t$Cumul($Case)\t$Case\tTaxId:$TaxId\tOS:$OSUnderscore\tReferenceClade:$CladeUnderscore"  
	}
	MemoCase $TaxId LaCase $LaCase
	if {$AvecHisto} {
	    set Couleur [Nuance [expr 1.0*$IemeTaxId/$NbTaxId]]
	    Graphe $LesX $LesY $K $Couleur "" "" "" "" "HistoDelta" $LesTags "" "BindOnly_oval" $LargeurMax $HauteurMax
	} else {
	    #	    set F [AfficheListe $LaCase "AvecCase" $OS]
	    #	    set B [BoutonneLaFenetre $F "ShowHits" "ShowHitsFromTaxoBlast \[selection get\]"]
	    #	    $B configure -background "Magenta"
	}
	
    }
    
    if {$GetWhat=="Show"} {
	set F [AfficheListe $LaSortie "" "Delta distribution for $Clade"]
	set B [BoutonneLaFenetre $F "Distribution" "ShowDeltaDistribution \[selection get\]"]
	$B configure -background "Magenta"
    }
    
    return $LaSortie
}