#rR gscope_liste.tcl

proc LesFantomes {} {
    foreach Nom [ListeDesPABs] {
	if { ! [Fantome $Nom]} { continue  }
	Espionne "$Nom [ExtraitInfo $Nom Fantome]"
	lappend LesFantomes $Nom
    }
    return $LesFantomes
}

proc PlaceDuPAB Nom {
    set i -1
    foreach PAB [ListeDesPABs] {
	incr i
	if {$PAB==$Nom} { return $i }
    }
    return -1
}

proc MiseAJourBornesDesPABs {NouvelleBorne {ReCharge ""}} {

    if {$ReCharge==""} { set ReCharge "ReCharge" }
    if {$ReCharge=="ReCharge" } { set ReCharge 1 } else { set ReCharge 0 }

    set FichierBornesDesPABs "[RepertoireDuGenome]/fiches/bornesdespabs"
    scan $NouvelleBorne "%s %d %d %s" Nom Debut Fin Orient
    set BelleBorne "$Nom $Debut $Fin $Orient"

    set LesBornes {}
    foreach Ligne [LesLignesDuFichier $FichierBornesDesPABs] {
	if { ! [regexp -nocase {[A-Z_]+[0-9]+ +[0-9]+ +[0-9]+ [FR] *} $Ligne]} {
	    if {[regexp -nocase {[A-Z0-9]} $Ligne]} {
		FaireLire "I'll skip the illegal line \n$Ligne"
	    }
	    continue
	}
	scan $Ligne "%s %d %d %s" N D F O
	lappend LesBornes "$N $D $F $O"
    }
    if {[set i [PlaceDuPAB $Nom]]<0} {
	lappend LesBornes "$Nom $Debut $Fin $Orient"
    } else {
	set LesBornes [lreplace $LesBornes $i $i $BelleBorne]	
    }
    SauveLesLignes $LesBornes dans $FichierBornesDesPABs

    if { ! $ReCharge } { return "" }

    global ListeDesPABs  ; unset ListeDesPABs
    global ListeDeBoites ; unset ListeDeBoites
    return [ListeDesPABs]
}

proc PresentationDesPABs {} {
    set LaPresentation {}
    foreach Nom [ListeDesPABs] {
	set Alias [Alias $Nom]
	set Defin [DefinitionRapide $Nom]
	set Ligne [format "%s %-15s %s" $Nom $Alias $Defin]
	lappend LaPresentation $Ligne
    }
    return $LaPresentation
}

proc LesBanquesDeLaFerme Ferme {
    set OnAttendPP 1
    set LesBanques {}
    foreach Ligne [LesLignesDuFichier $Ferme] {
	if {$OnAttendPP} {
	    if {[regexp {\.\.} $Ligne]} { set OnAttendPP 0 }
	    continue
	}
	scan $Ligne "%s" B
	lappend LesBanques $B
    }
    return $LesBanques
}

proc BlastHitCount {Nom {Rep ""} {CutPN ""} {MaxListe ""}} {
    Wup "If Nom contains / then Rep is CutPN and CutPN is Maxlist"
    Wup "If Rep doesn't contain / I add RepertoireDuGenome"
    Wup "The default for Rep is blastp"
 
    if {[regexp "/" $Nom]} {
	set MaxListe $CutPN
	set CutPN $Rep
	set Rep [file dirname $Nom]
	set Nom [file tail $Nom]
    } else {
	if {[regexp -nocase {^[0-9\-\.e]+$} $Rep] || $Rep=="SansSeuilExpect" } {
	    set MaxLists $CutPN
	    set CutPN $Rep
	    set Rep ""
	}
	if {$Rep==""} { set Rep "blastp" }
	if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
    }
    set Fichier "$Rep/$Nom"

    if { ! [file exists $Fichier]} { return -1 }
    return [DecortiqueBlast $Fichier $CutPN $MaxListe "BlastHitCount"]
}

proc ToutSurLesEntetesDeFrag {FichierFrag {Rep ""}} {

    if {$Rep==""} { set Rep "SameDir" }
    if {$Rep=="SameDir"} { set Rep "[file dirname $FichierFrag]" }

    set LesBanques {}
    foreach Ligne [LesLignesDuFichier $FichierFrag] {
	regsub {\:} $Ligne " " Ligne
	scan $Ligne "%s" Banque
	set LesMots [split $Ligne " "]
	set Genre [lindex $LesMots 9]
	set Espece [lindex $LesMots 10]
	if {[info exists DejaVu($Banque)]} { continue }
	set DejaVu($Banque) 1
	lappend LesBanques $Banque
	lappend LesOrganismes "$Genre $Espece"
    }
    set LesBonnesBanques {}
    foreach SN $LesBanques O $LesOrganismes {
	set FN [FNduSNgcg $SN]
	set LN [LNduSNgcg $SN]
	if {$FN==""} { FaireLire "$SN inconnu" ; continue }
	ScanLaListe [split $FN ":"] Dir Fic
	if {$LN!=$Fic} { FaireLire "FN $FN <> LN $LN" }
	if {[catch {set VraieDir [exec name $Dir]} Message]} {
	    FaireLire "Problem with 'exec name $Dir'\ I got message \n$Message"
	    continue
	}
	set BonRef ""
	foreach FiRef [glob -nocomplain "$VraieDir/*.ref"] {
	    set Queue [file tail $FiRef]
	    if {[string equal -nocase $Queue "$Fic.ref"]} { set BonRef $FiRef ; break } 
	}
	if {$BonRef==""} { Warne "$VraieDir/$Fic.ref doen't exist" }
	set TaxId [TaxIdDuFichierRef $BonRef]
	set TaxIdDuO [Tax $O]
	Espionne "$O<$TaxIdDuO>"
	if {$TaxId==""} {
	    if {$TaxIdDuO==""} { FaireLire "I didn't found a TaxId for\n$BonRef" }
	    set TaxId $TaxIdDuO
	}
	set N 7
	set TaxIdAuBonNiveau $TaxId
	while { [incr N -1] } {
	    Espionne "$N $TaxIdAuBonNiveau $TaxIdDuO"
	    if {$TaxIdAuBonNiveau==$TaxIdDuO} { break }
	    set TaxIdAuBonNiveau [Tax $TaxIdAuBonNiveau Parent]
	}
	if {0 && $TaxIdAuBonNiveau!=$TaxIdDuO} { FaireLire "$TaxIdDuO is not a parent of $TaxId for \n$BonRef" }
	lappend LesBonnesBanques "$SN $BonRef $TaxId"
	set TaxIdDuGenomeComplet($SN) $TaxId
	set RefDuGenomeComplet($SN) $BonRef
    }
    if {[OuiOuNon "Do I save TaxIdDuGenomeComplet ?"]} {
	set FichierTaxIdDuGenomeComplet "/genomics/link/Common/fiches/taxid_des_genomes_complets"
	SauveLesLignes [array get TaxIdDuGenomeComplet] dans $FichierTaxIdDuGenomeComplet
    } 
    if {[OuiOuNon "Do I save RefDuGenomeComplet ?"]} {
	set FichierRefDuGenomeComplet "/genomics/link/Common/fiches/ref_des_genomes_complets"
	SauveLesLignes [array get RefDuGenomeComplet] dans $FichierRefDuGenomeComplet
    } 
    return $LesBonnesBanques
}

proc A_Voir_LesBanquesDesEntetesDeFrag {FichierFrag {Rep ""}} {

    if {$Rep==""} { set Rep "SameDir" }
    if {$Rep=="SameDir"} { set Rep "[file dirname $FichierFrag]" }

    set LesBanques {}
    foreach Ligne [LesLignesDuFichier $FichierFrag] {
	regsub {\:} $Ligne " " Ligne
	scan $Ligne "%s" Banque
	lappend LesBanques $Banque
    }
    set LesBonnesBanques {}
    foreach Banque $LesBanques {
	set Banque [file tail $Banque]
	set BonneBanque "$Rep/$Banque"
	set Nhr "$BonneBanque.nhr"
	if { ! [file exists $Nhr]} { FaireLire "$Nhr n'existe pas" }
	if {[catch {set Name [exec name $Banque]} Message]} {
	    FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
	    continue
	}
	if {[regexp "^@GenDBConfigFiles" $Name]} {
	    regsub "^@" $Name "" Name
	    set NameDir [lindex [split $Name ":"] 0]
	    set Ferme   [lindex [split $Name ":"] 1]
	    if {[catch {set Dir [exec name $NameDir]} Message]} {
		FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
		continue
	    }
	    set Farm "$Dir/$Ferme"
	    if { ! [file exists $Farm]} { FaireLire "$Farm doesn't exists" ; continue }
	    foreach B [LesBanquesDeLaFerme $Farm] {
		Espionne "B $B"
		if {[catch {set NameDeB [exec name $B]} Message]} {
		    FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
		    continue
		}
		set NameDirDeB [lindex [split $NameDeB ":"] 0]
		if {[catch {set DirDeB [exec name $NameDirDeB]} Message]} {
		    FaireLire "Problem with 'exec name $NameDirDeB'\ I got message \n$Message"
		    continue
		}
		lappend LesBonnesBanques "$BonneBanque $DirDeB $NameDeB"
	    }
	} else {
	    set NameDir [lindex [split $Name ":"] 0]
	    if {[catch {set Dir [exec name $NameDir]} Message]} {
		FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
		continue
	    }
	    lappend LesBonnesBanques "$BonneBanque $Dir $Name"
	}
    }
    return $LesBonnesBanques
}

proc Nouveau_LesBanquesDuNal {Fichier {Rep ""}} {

    if {$Rep==""} { set Rep "SameDir" }
    if {$Rep=="SameDir"} { set Rep "[file dirname $Fichier]" }

    set LesBanques {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp "^DBLIST " $Ligne]} { continue }
	while {[regsub -all "  " $Ligne " " Ligne]} {}
	set Ligne [string trim $Ligne]
	set LesBanques [lrange [split $Ligne " "] 1 end] 
    }
    set LesBonnesBanques {}
    foreach Banque $LesBanques {
	set Banque [file tail $Banque]
	set BonneBanque "$Rep/$Banque"
	set Nhr "$BonneBanque.nhr"
	if { ! [file exists $Nhr]} { FaireLire "$Nhr n'existe pas" }
	if {[catch {set Name [exec name $Banque]} Message]} {
	    FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
	    continue
	}
	if {[regexp "^@GenDBConfigFiles" $Name]} {
	    regsub "^@" $Name "" Name
	    set NameDir [lindex [split $Name ":"] 0]
	    set Ferme   [lindex [split $Name ":"] 1]
	    if {[catch {set Dir [exec name $NameDir]} Message]} {
		FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
		continue
	    }
	    set Farm "$Dir/$Ferme"
	    if { ! [file exists $Farm]} { FaireLire "$Farm doesn't exists" ; continue }
	    foreach B [LesBanquesDeLaFerme $Farm] {
		if {[catch {set NameDeB [exec name $B]} Message]} {
		    FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
		    continue
		}
		set NameDirDeB [lindex [split $NameDeB ":"] 0]
		if {[catch {set DirDeB [exec name $NameDirDeB]} Message]} {
		    FaireLire "Problem with 'exec name $NameDirDeB'\ I got message \n$Message"
		    continue
		}
		lappend LesBonnesBanques "$BonneBanque $DirDeB $NameDeB"
	    }
	} else {
	    set NameDir [lindex [split $Name ":"] 0]
	    if {[catch {set Dir [exec name $NameDir]} Message]} {
		FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
		continue
	    }
	    lappend LesBonnesBanques "$BonneBanque $Dir $Name"
	}
    }
    return $LesBonnesBanques
}

proc LesBanquesDuNal {Fichier {Rep ""}} {

    if {$Rep==""} { set Rep "SameDir" }
    if {$Rep=="SameDir"} { set Rep "[file dirname $Fichier]/" }

    set LesBanques {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp "^DBLIST " $Ligne]} { continue }
	while {[regsub -all "  " $Ligne " " Ligne]} {}
	set LesBanques [lrange [split $Ligne " "] 1 end] 
    }
    set LesBonnesBanques {}
    foreach Banque $LesBanques {
	set Banque [file tail $Banque]
	lappend LesBonnesBanques "$Rep$Banque"
    }
    return $LesBonnesBanques
}

proc VerifieLesGenomesCompletsIGBMC {{Fichier ""}} {
    if {$Fichier==""} { set Fichier "/genome/GCGdbs" }
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	if { ! [regexp {^[ \t]} $Ligne]} { continue }
	if {[regexp "All the " $Ligne]} { continue }
	regsub -all {\.} $Ligne " " Ligne
	scan $Ligne "%s %s" Genre Espece
	if {$Espece=="sp"} { set Espece "sp." }
	set Organisme [Glossaire "$Genre $Espece" Complet]
	if {[info exists DejaVu($Organisme)]} { continue }
	set DejaVu($Organisme) 1
	if {$Organisme!="$Genre $Espece"} {
	    if {$Organisme==""} {
		set Trouve "nothing"
	    } else {
		set Trouve "'$Organisme'"
	    }
	    set Bon ""
	    if {[OuiOuNon "I found $Trouve for\n$Ligne\n Do I keep '$Genre $Espece' ?"]} {
		set Bon "$Genre $Espece"
	    }
	    if {$Bon=="" && $Organisme!="" && [OuiOuNon " Do I keep '$Organisme' ?"]} {
		set Bon "$Genre $Espece"
	    }
	    if {$Bon==""} { continue }
	}
	lappend LesOrganismes $Organisme
    }

    set LesBons [ChoixDesPresents $LesOrganismes]
    return $LesBons
}

proc RetireLesAccessDuMSF {FichierAvant LesAccess {FichierApres ""} {InOut "Out"}} {

    if {$InOut=="In"} { set In 1 } else { set In 0 }

    set LeNouveau {}
    foreach Ligne [LesLignesDuFichier $FichierAvant] {
	if {[regexp "^PileUp" $Ligne] || \
		! [regexp -nocase {[a-z0-9]} $Ligne] } { lappend LeNouveau $Ligne ; continue }
	set Tope 0
	scan $Ligne "%s %s" Access AccessBis
	if {[regexp -nocase "Name:" $Ligne]} {
	    set Access $AccessBis
	}
	foreach AccessARetirer $LesAccess {
	    if {[string equal -nocase $AccessARetirer $Access]} { set Tope 1 ; break }
	}
	if {   $Tope && ! $In } { continue }
	if { ! $Tope &&   $In } { continue }
	lappend LeNouveau $Ligne
    }
    if {$FichierApres=="" | $FichierApres=="GetLines"} { return $LeNouveau }
    return [SauveLesLignes $LeNouveau dans $FichierApres]
}

proc ListEqual {A B} {
    if {[llength $A]!=[llength $B]} { return 0 }
    foreach a $A b $B {
	if {[set L [llength $a]]!=[llength $b]} { return 0 }
	if {$L>1} {
	    if { ! [ListEqual $a $b]} { return 0 }
	} else {
	    if {$a != $b} { return 0 } 
	}
    }
    return 1
}

proc SetOptions Liste {

    set LesValeurs [lrange $Liste 1 end]
    lappend LesValeurs 1

    foreach Option $Liste Valeur $LesValeurs {
	if { ! [regexp {^\-} $Option]} { continue }
	regsub {^\-} $Option "" Option
	if {[regexp {^[0-9]} $Option]} { continue }
	lappend LesOptions $Option
	if {[regexp {^\-[^0-9]} $Valeur]} { set Valeur 1 }
	uplevel set $Option \"$Valeur\"
    }
    return $LesOptions
}

proc TestSetOptions {A B C D args} {

    set LesOptions [SetOptions $args]

    foreach Option $LesOptions {
	Espionne "$Option [set $Option]"
    }
    exit 
}

proc DupliqueLaBaseGscope {{RepDestin ""}} {
    global RepertoireDuGenome

    while {1} {
	if {$RepDestin==""} { set RepDestin "${RepertoireDuGenome}COPY" }
	
	if { ! [regexp "/" $RepDestin]} {
	    set RepDestin "[file dirname $RepertoireDuGenome]/$RepDestin"
	}
	if { ! [OuiOuNon "Ok to duplicate \n\
		$RepertoireDuGenome\n to \
		$RepDestin\n \
		?"]} {
	    set RepDestin [Entre $RepDestin]
	}
	if {$RepDestin!=""} { break } 
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }

    while {! [file exists $RepDestin]} {
	if {[OuiOuNon "Please create the directory of the new gscope database \n\
		$RepDestin\
		OK ?"]} { continue }
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }

    foreach Rep {"beton" "nuctfa" "nucembl" "prottfa" "protembl" "infos" "trnadir" "codonw"} {
	set Source "$RepertoireDuGenome/$Rep"
	set Destin "$RepDestin/$Rep"
	if { ! [file exists $Source]} { continue }
	Espionne "$Source to $Destin"
	if { ! [info exists $Destin]} { File mkdir $Destin }
	foreach Fichier [glob -nocomplain "$Source/*"] {
	    set Nom [file tail $Fichier]
	    File copy $Fichier "$Destin/$Nom"
	}
    }
    set Source "$RepertoireDuGenome/fiches"
    set Destin "$RepDestin/fiches"
    if { ! [file exists $Destin]} { File mkdir $Destin }
    if {[file exists $Source]} {
	foreach F { \
		bornesdesarns \
		bornesdesglimmers \
		bornesdespabs \
		bornesdestrnas \
		codonstartpossible \
		codonstoppossible \
		coglimmer \
		compositionenatgc \
		createurdespabs \
		lesorganismestresproches \
		narcisse \
		sd_bons \
		sd_loin \
		sd_mets \
		sd_sans \
		similarite \
		spectregc \
		spectregcxy \
		startcodon_summary } {
	    if { ! [file exists $Source/$F]} { continue }
	    Espionne "$Source/$F to $Destin/$F"
	    File copy "$Source/$F" "$Destin/$F"
	}
    }
    return 
}

proc SplitLeGrosGenbank {{Fichier ""} {Petit ""}} {
    global RepertoireDuGenome
    if {$Fichier==""} {
	set Fichier [ButineArborescence "All" "$RepertoireDuGenome"]
    }
    if {$Fichier==""} { return {} }

    set n 1
    foreach Ligne [LesLignesDuFichier $Fichier] {
	lappend T($n) $Ligne
	if {[regexp "^//" $Ligne]} { incr n }
    }
    incr n -1

    if {$n==1} {
	FaireLire "I found only one section in $Fichier"
    }
    set Format "%5.5d"
    if {  1<$n && $n<   10} { set Format "%1.1d" }
    if {  9<$n && $n<  100} { set Format "%2.2d" }
    if { 99<$n && $n< 1000} { set Format "%3.3d" }
    if {999<$n && $n<10000} { set Format "%4.4d" }

    if {$Petit==""} {
	set Petit [file tail $Fichier]
	set Rep [file dirname $Fichier]
	regsub ".gbk$" $Petit "" Petit
	regsub -nocase {_[a-z]*$} $Petit "" Petit
	append Petit "_"
	while {1} {
	    set PetitMin [format "%s$Format%s" $Petit  1 ".gbk"]
	    set PetitMax [format "%s$Format%s" $Petit $n ".gbk"]
	    if {[OuiOuNon "I will create the files\n$PetitMin to $PetitMax\nin $Rep"]} { break }
	    set Petit [Entre $Petit]
	}
    }
    
    foreach i [NombresEntre 1 $n] {
	set PetitNom [format "%s$Format%s" $Petit  $i ".gbk"]
	set PetitFichier [SauveLesLignes [set T($i)] dans "$Rep/$PetitNom"]
	lappend LesPetits $PetitFichier
    }
    return $LesPetits
}

proc MMm {} {

    global Coucou T _1T
    set Coucou "bonjour\nsalut"
    set T(1) "Je suis sur \n deux lignes"

    set _1T(a) "1ta"

    foreach Variable [info globals] {
	global $Variable
	if {[regexp "Glossaire" $Variable]} { continue }
	if { ! [info exists $Variable]} { continue }
	if {[array exists $Variable]} {
	    lappend LesGlobal [PaqArray [set Variable]]
	} else {
	    lappend LesGlobal [PaqListe $Variable [set $Variable]]
	}
    }
    set Coucou perdu
    unset _1T
    EspionneL $LesGlobal
    Espionne "Fin de LesGlobal"
    set LesV [AffecteLesVariablesDeLaListe $LesGlobal]
    foreach V $LesV {
	if {[array exists $V]} {
	    Espionne "$V [array get $V]"
	} else {
	    Espionne "$V [set $V]"
	}
    }
    Espionne $Coucou
    Espionne $T(1)
    Espionne $_1T(a)
    exit
}

proc Aujourdhui {} {
    scan [Today] "%s %s %s %s" S J M A
    set Aujourdhui "[Traduction $S francais] $J [Traduction $M francais] $A"
    return $Aujourdhui
}

proc Today {} {
    return [clock format [clock seconds] -format "%A %d %B %Y"]
}

proc IllumineSuivantLesGroupes {LesAGs Fenetre} {
    set OldG Bidon
    set Lumiere 0
    foreach Ligne $LesAGs {
	scan $Ligne "%s %s" A G
	if {$OldG!=$G} { set Lumiere [expr ! $Lumiere] }
	set OldG $G
	if {$Lumiere} { Illumine $A $Fenetre }
    }
}

proc MontreSecator MSF {
    set FiMSF [Sauve $MSF dans [TmpFile "secator"]] 
    set LesAGs [GroupeSecator $FiMSF "" "ToutLeMondeAvecGroupe" "ToCalculate"]
    set Fenetre [AfficheVariable [join $LesAGs "\n"] ""]
    IllumineSuivantLesGroupes $LesAGs $Fenetre
    MemoSelection $Fenetre Memorize
    return $LesAGs
}

proc AfficheReordonneMSF {MSF {LesAccess ""} {FichierOrigine ""}} {

    if {$LesAccess=="" || $LesAccess=="Ask"} { 
	set LesAccess [ChoixParmi {"Disphy" "Secator" "Dpc" "Oumy" "ShowSecator"}]
	if {$LesAccess==""} { return "" }
    }

    if {$LesAccess=="ShowSecator"} {
	MontreSecator $MSF
    }

    set Nom [file tail $FichierOrigine]

    set Fenetre [AfficheVariable [ReordonneMSF $MSF $LesAccess $Nom] "AvecEtudeMSFGrandeLargeur" "$FichierOrigine"]
    if {$LesAccess=="Disphy"} { return $Fenetre }
    set LesAGs [MontreSecator $MSF]
    IllumineSuivantLesGroupes $LesAGs $Fenetre
    MemoSelection $Fenetre Memorize
    return $Fenetre
}

proc DiffBlaAli Nom {
    global RepertoireDuGenome
    global DiffBlaAli

    if {[info exists DiffBlaAli($Nom)]} { return [set DiffBlaAli($Nom)] }
    if {[info exists DiffBlaAli]} { return "" }

    set DiffBlaAli("EstCharge") 1

    set FichierDiffBlaAli "$RepertoireDuGenome/fiches/diffblaali"
    if { ! [file exists $FichierDiffBlaAli]} { return "" }
	
    foreach DBA [LesLignesDuFichier $FichierDiffBlaAli] {
	scan $DBA "%s %s" NomLu Rapport 
	if {[regexp "No(More|Bla|Ali)" $Rapport]} {
	    set DiffBlaAli($NomLu) $Rapport
	    continue
	}

	scan $DBA "%s %s %s %s %s %s %s %s" NomLu BestBla BestAli DisBla DisAli Ecart Rapport Fragments

	set DiffBlaAli($NomLu) "$Rapport $BestBla $BestAli"
    }
    if {[info exists DiffBlaAli($Nom)]} { return [set DiffBlaAli($Nom)] }
    return ""
}

proc RapportDuDifferentiel {DisBla DisAli {Test "AvecDis"}} {

    if {$Test=="AvecDis"} {
	set MaxDis [Maxi [Maxi $DisAli $DisBla] 1]
	set EcartDis [Maxi 0 [expr ($DisBla-$DisAli) - 1]]
	set EcartDisProp [expr (100*$EcartDis)/100]
	set SeuilEcartDisProp 5
	if {$EcartDisProp > $SeuilEcartDisProp} {
	    set Rapport "Different"
	} else {
	    set Rapport "Close"
	}
	set Ecart $EcartDisProp
	return "$Rapport $Ecart"
    }

    if {$Test=="AvecPI"} {
	set SeuilEcartPI 90
	set EcartPI [expr 100-($DisBla-$DisAli)]
	if {$EcartPI < $SeuilEcartPI} {
	    set Rapport "Different"
	} else {
	    set Rapport "Close"
	}
	set Ecart $EcartPI
	return "$Rapport $Ecart"
    }
}

proc ReconsidereLesDifferentiels {} {
    global RepertoireDuGenome

    set LesXDifferent {} 
    set LesYDifferent {}
    set LesXClose {} 
    set LesYClose {}
    foreach DiffBlaAli [LesLignesDuFichier "$RepertoireDuGenome/fiches/diffblaali"] {
	scan $DiffBlaAli "%s %s" Nom Rapport 
	if {[regexp "No(More|Bla|Ali)" $Rapport]} {
	    lappend Sortie $DiffBlaAli 
	    continue
	}

	scan $DiffBlaAli "%s %s %s %s %s %s %s %s" Nom BestBla BestAli DisBla DisAli Ecart Rapport Fragments

	if { ! [regexp "Problem" $Rapport] && ! [regexp "Same" $Rapport]} {
	    scan [RapportDuDifferentiel $DisBla $DisAli] "%s %d" Rapport Ecart
	}
	set Beau [format "%s %-9s %-9s %3d %3d %3d %-10s %s" \
		$Nom $BestBla $BestAli $DisBla $DisAli $Ecart $Rapport $Fragments]

	lappend LesX $DisBla
	lappend LesY $DisAli
	if {$Rapport=="Different"} {
	    lappend LesXDifferent $DisBla
	    lappend LesYDifferent $DisAli
	}
	if {$Rapport=="Close"} {
	    lappend LesXClose $DisBla
	    lappend LesYClose $DisAli
	}
	lappend Sortie $Beau
    }
    SauveLesLignes $Sortie dans "$RepertoireDuGenome/fiches/diffblaali"
    set K [Graphe $LesX          $LesY          "" "green"]
           Graphe $LesXClose     $LesYClose     $K "blue"
           Graphe $LesXDifferent $LesYDifferent $K "red"
    MainLeveeSurUnCanva $K
}

proc ShowDifferentielBlastAlignement Selection {
    global RepertoireDuGenome
    Gs "Frame"
    
    foreach DiffBlaAli [split $Selection "\n"] {
	scan $DiffBlaAli "%s %s" Nom Rapport 
	if {[regexp NoMore $Rapport]} {
	    FaireLire "$Rapport for $Nom"
	    continue
	}
	scan $DiffBlaAli "%s %s %s %s %s %s %s" Nom BestBla BestAli DisBla DisAli Ecart Rapport
	if {[regexp "Problem|Same" $Rapport]} {
	    FaireLire "$DiffBlaAli"
	    continue
	}
	set ToShow "$Nom\n$BestBla\n$BestAli"
	set FichierMSF "$RepertoireDuGenome/msf/$Nom"
	set MSF [ContenuDuFichier $FichierMSF]
	regsub -nocase "Name: $BestBla oo " $MSF "Name: $BestBla $DisBla" MSF
	regsub -nocase "Name: $BestAli oo " $MSF "Name: $BestAli $DisAli" MSF
	set Fen [AfficheRognure $MSF $ToShow "" $FichierMSF "In"]
	Illumine $BestAli                  $Fen
	Illumine [string toupper $BestAli] $Fen
	continue
    }
}

proc MSFSelection {FichierOuTexteMSF LesAccess {InOut "In"}}  {

    if {[EstUnPAB $FichierOuTexteMSF]} { set FichierOuTexteMSF [GscopeFile $FichierOuTexteMSF "msf"] }
    set TexteMSF $FichierOuTexteMSF
    if { ! [regexp "\n" $FichierOuTexteMSF] && [file exists $FichierOuTexteMSF]} {
	set TexteMSF [ContenuDuFichier $FichierOuTexteMSF]
    }

    if {$InOut=="In"} { set In 1 } else { set In 0 }

    foreach Access $LesAccess {
	set ACCESS [string toupper $Access]
	set InterestingAccess($ACCESS) 1
    }


    set LesNouveaux {}
    foreach Ligne [split $TexteMSF "\n"] {
	if {[regexp "^PileUp" $Ligne] || \
		[regexp {^ANCHORS [0-9]+} $Ligne] || \
		[regexp {^ +MSF\:} $Ligne] || \
		! [regexp -nocase {[a-z0-9]} $Ligne] } { lappend LesNouveaux $Ligne ; continue }
	set Tope 0
	if {[regexp -nocase {Name: [a-z0-9_\:\-]} $Ligne]} {
	    scan $Ligne "%s %s" Name Access
	} else {
	    scan $Ligne "%s" Access
	}
	set ACCESS [string toupper $Access]
	set Tope [info exists InterestingAccess($ACCESS)]
	if {   $Tope && ! $In } { continue }
	if { ! $Tope &&   $In } { continue }
	lappend LesNouveaux $Ligne
    }
    return [join $LesNouveaux "\n"]
}

proc AfficheRognure {Page Selection Maniere NomDuFichierOrigine {InOut "In"}} {

    if {$InOut=="Alone"} {
	if {$Maniere=="Retour"} { return $Selection }
	return [AfficheVariable $Selection $Maniere $NomDuFichierOrigine]
    }

    set LesAccess {}
    foreach Ligne [split $Selection "\n"] {
	regsub "Name:" $Ligne "" Ligne
	set Access ""
	scan $Ligne "%s" Access
	if {$Access==""} { continue }
	lappend LesAccess $Access
    }
    set NouvellePage [MSFSelection $Page $LesAccess $InOut]

    if {$Maniere=="Retour"} { return $NouvellePage }
    return [AfficheVariable $NouvellePage $Maniere "$NomDuFichierOrigine"]
}

proc FromDisphyOf {A B} {
    FromDisphy $A
    return [FromDisphy $B]
}

proc FromDisphy NomOuFichier {
    global RepertoireDuGenome
    global FromDisphy

    Wup "returns the list of all accesses and stores the distances in memory"

    set M [string toupper $NomOuFichier]
    if {[info exists FromDisphy($M)]} { return [set FromDisphy($M)] }

    if {[info exists FromDisphy]} { unset FromDisphy }


    set Nom [file tail $NomOuFichier]
    set FichierDisphy $NomOuFichier
    if { ! [file exists $FichierDisphy]} {
	set FichierDisphy "$RepertoireDuGenome/disphy/$Nom"
    }
    if { ! [file exists $FichierDisphy]} { return {} }

    set LesAccess {}
    foreach Ligne [LesLignesDuFichier $FichierDisphy] {
	set Access ""
	scan $Ligne "%s %s %s" Orga Dis Access
	if {$Access==""} { continue }
	set ACCESS [string toupper $Access]
	set FromDisphy($ACCESS) $Dis
	lappend LesAccess $Access
    }
    set FromDisphy($NomOuFichier) $LesAccess
    return $LesAccess
}

proc LesAccessDuAPN NomOuFichier {
    global RepertoireDuGenome

    set Nom [file tail $NomOuFichier]
    set FichierAPN $NomOuFichier
    if { ! [file exists $FichierAPN]} {
	set FichierAPN "$RepertoireDuGenome/apns/$Nom"
    }
    if { ! [file exists $FichierAPN]} { return {} }

    set LesAccess {}
    foreach Ligne [LesLignesDuFichier $FichierAPN] {
	set Access ""
	scan $Ligne "%s %s %s" BanqueId Access PN
	if {$Access==""} { continue }
	lappend LesAccess $Access
    }
    return $LesAccess
}

proc DifferentielBlastAlignementPourTous {} {
    global RepertoireDuGenome

    set FichierDiffBlaAli "$RepertoireDuGenome/fiches/diffblaali"

    while {[file exists $FichierDiffBlaAli]} {
	if {[OuiOuNon "The file differential blastp alignment already exists. \n Do I replace it ?"]} {
	    File delete $FichierDiffBlaAli
	    continue
	}
	if {[OuiOuNon "Do I append to it ?"]} {
	    foreach Ligne [LesLignesDuFichier $FichierDiffBlaAli] {
		scan $Ligne "%s" Nom
		set BlaAli($Nom) $Ligne
	    }
	    break
	}
    }

    foreach Nom [ListeDesPABs] {
	if {[info exists BlaAli($Nom)]} { continue }
	set Differentiel [DifferentielBlastAlignement $Nom]
	AppendAuFichier $FichierDiffBlaAli "$Differentiel"
	if { [regexp " Same " $Differentiel]} { continue }
	Espionne "$Differentiel"
    }
    
    return $FichierDiffBlaAli
}

proc DifferentielBlastAlignement Nom {
    global RepertoireDuGenome
    global NotreOS
    global NotreOrga

    set AvecShow 0

    set FichierAli "$RepertoireDuGenome/disphy/$Nom"
    if { ! [file exists $FichierAli]} { return "$Nom NoAli" }
    set FichierBla "$RepertoireDuGenome/apns/$Nom"
    if { ! [file exists $FichierBla]} { set FichierBla "$RepertoireDuGenome/blastp/$Nom" }
    if { ! [file exists $FichierAli]} { return "$Nom NoBla" }
    set DescriAli [AfficheLesDescriptifs $FichierAli "MemeOrdre" "LaListe"]
    set LesBonsAli {}
    foreach Ligne $DescriAli {
	if {[regexp [ExpressionReguliereDesPABs] [lindex [split $Ligne " "] 0]]} { continue }
	if {[regexp -nocase "OS:$NotreOS" $Ligne]} { continue }
	lappend LesBonsAli $Ligne
    }
    if {$LesBonsAli=={}} { return "$Nom NoMoreAli" }
    set DescriBla [AfficheLesDescriptifs $FichierBla "MemeOrdre" "LaListe"]
    set LesBonsBla {}
    foreach Ligne $DescriBla {
	if {[regexp [ExpressionReguliereDesPABs] [lindex [split $Ligne " "] 0]]} { continue }
	if {[regexp -nocase "OS:$NotreOS" $Ligne]} { continue }
	lappend LesBonsBla $Ligne
    }
    if {$LesBonsBla=={}} { return "$Nom NoMoreBla" }

    set Rapport "NotYetValued"

    scan [lindex $LesBonsBla 0] "%s" BestBla
    scan [lindex $LesBonsAli 0] "%s" BestAli
    if {[string equal -nocase $BestBla $BestAli]} {
	set Rapport "Same"
	set Ecart   000
	set DisBla  000
	set DisAli  000
    }

    if {$Rapport!="Same"} {
	FromDisphy $Nom
	set DisBla [FromDisphy $BestBla]
	set DisAli [FromDisphy $BestAli]
	if { ! [regexp {^[0-9]+$} $DisBla] || ! [regexp {^[0-9]+$} $DisAli]} {
	    set DisBla 0
	    set DisAli 0
	    set Ecart  0
	    set Rapport "Problem"
	} else {
	    scan [RapportDuDifferentiel $DisBla $DisAli] "%s %d" Rapport Ecart
	}
    }
    set Fragments ".."
    if {$Rapport!="Same"} {
	set DEBla [ChampDuDescriptif [LeDescriptif $BestBla $Nom] DE]
	set DEAli [ChampDuDescriptif [LeDescriptif $BestAli $Nom] DE]
	set FraBla [regexp -nocase "FRAGMENT" $DEBla]
	set FraAli [regexp -nocase "FRAGMENT" $DEAli]
	if {$FraBla} { set FraBla "F" } else { set FraBla "-" }
	if {$FraAli} { set FraAli "F" } else { set FraAli "-" }
	set Fragments "$FraBla$FraAli"
    }
    set Beau [format "%s %-9s %-9s %3d %3d %3d %-10s %s" \
	    $Nom $BestBla $BestAli $DisBla $DisAli $Ecart $Rapport $Fragments]

    return $Beau

}

proc ReorganiseLesDescriptifs Nom {
    global RepertoireDuGenome
    set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom"
    set FichierBlastP     "$RepertoireDuGenome/blastp/$Nom"

    foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
	regsub "Viridiplantae; Embryophyta;" $Ligne "Viridiplantae; Streptophyta; Embryophyta;" Ligne
	ScanLaListe [split $Ligne "="] Access Reste
	if {[info exists D($Access)] && [set D($Access)]!=$Ligne} {
	    set Stock [set D($Access)]
	    if {[regexp "Genre espece" $Stock] && ! [regexp "Genre espece" $Ligne]} {
		set D($Access) $Ligne
		continue
	    }
	    if { ! [regexp "Genre espece" $Stock] && [regexp "Genre espece" $Ligne]} { continue }
	    if { ! [regexp "Escherichia coli.  OX:" $Stock] && [regexp "Escherichia coli.  OX:" $Ligne]} { continue }
	    if { [regexp "Escherichia coli.  OX:" $Stock] && ! [regexp "Escherichia coli.  OX:" $Ligne]} {
		set D($Access) $Ligne
		continue
	    }
	    set i 0
	    while {1} {
		if {[string index $Stock $i]!=[string index $Ligne $i]} { break }
		incr i
	    }
	    set d [expr $i-40]
	    set f [expr $i+100]
	    set Fen [AfficheVariable "[string range $Stock $d $f]\n[string range $Ligne $d $f]" "AvecRien"]
	    set Garde [expr ! [OuiOuNon "Je prend le second ?"]]
	    after idle destroy $Fen
	    if {$Garde} { continue } 
	}
	set D($Access) $Ligne
    }
    exit
}

proc CreeStartCodonSummary {{Ask ""}} {
    global RepertoireDuGenome

    set FichierSummary  "$RepertoireDuGenome/fiches/startcodon_summary"
    if {$Ask=="FileName" && [file exists $FichierSummary]} { return $FichierSummary }

    if {$Ask=="" || $Ask=="Replace"} { set Ask 0 } else { set Ask 1}

    if {[file exists $FichierSummary]} {
	if { ! $Ask || [OuiOuNon "$FichierSummary\n already exists. Do I keep it ?" 0]} {
	    File delete $FichierSummary
	} else {
	   return $FichierSummary
	} 
    }

    set Sortie {}
    foreach Nom [ListeDesPABs] {
	set Poch [ExtraitInfo $Nom "met"]
	set MetRR [ExtraitInfo $Nom "MetRR"]
	set CS [CodonStart $Nom]
	if {$CS==""} { continue }
	set TailleDuGroupe 999
	set NombreDeSequences 999	
	if {[regexp "GroupSize" $CS]} {
	    scan $CS "%s %d %d" Bidon TailleDuGroupe NombreDeSequences
	    regsub {GroupSize [0-9]+ [0-9]+ } $CS "" CS
	}
	set LesDejaVus {}
	set OldOv [OverlapAtStart $Nom]
	FromDisphy $Nom
	Espionne "$Nom $CS"
	if { ! [regexp -nocase {^[A-Z]+ [0-9]+ } $CS]} { continue }
	if {[regexp -nocase " / " $CS]} {
	    FaireLire "I found an error in CodonStart. Please correct it"
	    set CS [Entre $CS]
	}
	foreach {AA P Accesses} [split $CS " "] {
	    set NewOv [expr $OldOv - ($P-1)*3]
	    if {$NewOv<0} { set NewOv "+[expr -$NewOv]" }
	    set LesAccess [split $Accesses "/"]
	    set nAcc [llength $LesAccess]
	    set CumulDisAli 0
	    set nCumul 0
	    set Distances ""
	    foreach Access $LesAccess {
		set DisAli [FromDisphy $Access]
		append Distances "/$DisAli"
		if {$DisAli==""} { continue }
		incr nCumul
		incr CumulDisAli $DisAli
	    }
	    if {$nCumul==0} {
		set MoyDisAli 999
	    } else {
		set MoyDisAli [expr $CumulDisAli/$nCumul]
	    }
	    Espionne "$Accesses\n$Distances $MoyDisAli"
	    set GGTtoATG [ShineDalgarnoSiNouveauMet $Nom $P]
	    set iGGT [string length $GGTtoATG]
	    
	    if {$MetRR==""} {
		set RemarquePochOuMetRR $Poch
	    } else {
		scan $MetRR "%s %d" MVL BonMet
		if {$BonMet==$P} {
		    set RemarquePochOuMetRR "Better $MetRR"
		} else {
		    set RemarquePochOuMetRR ""
		}
	    } 
	    lappend LesDejaVus [format "$Nom %3d %s %4d  %3d %4s  %3d/%3d %3d %3d = %-20s %s" \
		    $iGGT $AA $P $OldOv $NewOv \
		    $nAcc $TailleDuGroupe $NombreDeSequences $MoyDisAli \
		    $RemarquePochOuMetRR $GGTtoATG]
	}
	if {$LesDejaVus=={}} { continue }
	lappend Sortie "\n[join $LesDejaVus "\n"]"
    }
    return [SauveLesLignes $Sortie dans $FichierSummary]    
}

proc StartCodonSummary {Nom {Quoi "Summary"}} {
    global StartCodonSummary

    if {[info exists StartCodonSummary($Nom,$Quoi)]} {
	return [set StartCodonSummary($Nom,$Quoi)]
    }
    if {[info exists StartCodonSummary("EstCharge",Summary)]} {
	if {[info exists StartCodonSummary("EstCharge",Quoi)]} {
	    return [set StartCodonSummary("EstCharge",$Quoi)]
	} else {
	    return "NoSummaryExists"
	}
    }
    set FichierSummary [CreeStartCodonSummary "FileName"]
    if {$FichierSummary==""} {
	set StartCodonSummary("EstCharge",Summary) "NoSummaryAvalaible"
	return [StartCodonSummary $Nom $Quoi]
    }
    foreach Ligne [LesLignesDuFichier $FichierSummary] {
	if { ! [regexp -nocase {[A-Z]} $Ligne]} { continue }
	if {[regexp {[0-9]\+} $Ligne]} { regsub {\+} $Ligne " +" Ligne }
	scan $Ligne "%s" NomLu
	regsub "$NomLu *" $Ligne "" Summary
	lappend StartCodonSummary($NomLu,Summary) $Summary
	scan $Summary "%d %s %d" iGGT AA P
	set StartCodonSummary($NomLu,$P) $Summary
    }
    set StartCodonSummary("EstCharge",Summary) "NoSummaryExists"
    return [StartCodonSummary $Nom $Quoi]
}

proc ShineDalgarnoSiNouveauMet {Nom {P 0}} {
    global MotifShineDalgarno

    incr P -1

    if { ! [info exists MotifShineDalgarno]} {
	set Motif [CreeLesFichiersDesShineDalgarnoDesPABs "LeMotifMerci"]
    }
    set Motif $MotifShineDalgarno

    Wup "returns 1 if ShineDalgarno before alternative Met at position P"

    set MinSD -18
    set MaxSD -3

    set Debut  [Box $Nom debut]
    set Fin    [Box $Nom fin]
    set Orient [Box $Nom orient]

    if {$Orient=="F"} {
	set D [expr $Debut + $P*3 + $MinSD]
	set F [expr $Debut + $P*3 + $MaxSD]
	set dATG $D
	set fATG [expr $Debut + $P*3 + 2]
    } else {
	set D [expr $Fin - $P*3 - $MinSD]
	set F [expr $Fin - $P*3 - $MaxSD]
	set dATG [expr $Fin - $P*3 - 2]
	set fATG $F
    }

    set PlageSD [BoutADN $D $F $Orient] 
    if { ! [regexp -indices -nocase $Motif $PlageSD Indices]} { return "" }
    set i [lindex $Indices 0]

    set PlageAvantATG [BoutADN $dATG $fATG $Orient] 
    set GGTtoATG [string range $PlageAvantATG $i end]
    set GGT [string range $GGTtoATG 0 2]
    set ggt [string tolower $GGT]
    set ATG [string range $GGTtoATG end-2 end]
    set atg [string tolower $ATG]
    regsub "^$GGT" $GGTtoATG "$ggt" GGTtoATG
    regsub "$ATG$" $GGTtoATG "$atg" GGTtoATG
    set iGGT [expr -($MinSD+$i)]
    return $GGTtoATG    
}

proc LesMetsTropLoin {{Quoi "faux"}} {
    foreach Nom [ListeDesPABs] {
	set Valeur [CodonStart $Nom]
	if {$Valeur==""} { continue }
	foreach {M P As} [split $Valeur " "] {
	    set Poch [ExtraitInfo $Nom "met"]
	    if {[regexp "faux" $Poch]} {
		lappend Lesfaux  "$P faux $Nom"
	    }
	    if {[regexp "ok" $Poch]} {
		if {[info exists DejaVu($Nom)]} { continue } 
		lappend Lesok   "$P ok   $Nom"
	    }
	    if {[regexp "plau" $Poch]} {
		if {[info exists DejaVu($Nom)]} { continue } 
		lappend Lesplau "$P plau   $Nom"
	    }
	    set DejaVu($Nom) 1
	}
    }
    return [join [set Les$Quoi] "\n"]
}

proc EstUnFichierBlastP Fichier {
    set PremierMot [join [LesPremieresLignesDuFichier $Fichier 3] ""]
    Espionne $PremierMot
    return [regexp -nocase {^[ \t\n]*BLASTP} $PremierMot]
}

proc TestOrgaDuDescriptif {Nom1 Nom2}  {
    global RepertoireDuGenome

    foreach Nom [list $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2] {
	Espionne $Nom
	set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom"
	set LesAccess {}
	foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
	    ScanLaListe [split $Ligne "="] Access
	    lappend LesAccess $Access
	    Espionne $Access
	}
	set O [LesOrgasDesAccess $LesAccess Court $Nom]
    }
    exit
}

proc OrgaDuDescriptif {Access Nom} {
    global RepertoireDuGenome
    global OrgaDuDescriptif

    if {[info exists OrgaDuDescriptif($Access)]} { return [set OrgaDuDescriptif($Access)] }

    if {[info exists OrgaDuDescriptif($Nom,"EstCharge")]} { return "" }

    if {[info exists OrgaDuDescriptif]} { unset OrgaDuDescriptif }

    set OrgaDuDescriptif($Nom,"EstCharge") 1 

    set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom"
    if { ! [file exists $FichierDescriptif]} { return "coucou" }

    foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
	ScanLaListe [split $Ligne "="] AC Reste
	ScanLaListe [split $Ligne " "] Bidon OSGenre Espece
	regsub "OS\:" $OSGenre "" Genre
	set Organisme "$Genre $Espece"
	set OrgaDuDescriptif($AC) $Organisme
    }
    if {[info exists OrgaDuDescriptif($Access)]} {
	return [set OrgaDuDescriptif($Access)]
    } else {
	return ""
    }
}

proc Hydrophobicity {Nom {Quoi "nHelices"}} {
    global RepertoireDuGenome
    global Hydrophobicity

    Wup "Quoi can be nHelices Hydro or OwnHydro"

    if {[info exists Hydrophobicity($Nom,$Quoi)]} { return [set Hydrophobicity($Nom,$Quoi)] }
    if {[info exists Hydrophobicity]} { return -999 }

    set FichierHydrophobicity "$RepertoireDuGenome/fiches/hydrophobicity"

    if {[file exists $FichierHydrophobicity]} {
	foreach Ligne [LesLignesDuFichier $FichierHydrophobicity] {
	    scan $Ligne "%s %d %f %f" NomLu nHelices Hydro OwnHydro
	    set Hydrophobicity($NomLu,nHelices) $nHelices
	    set Hydrophobicity($NomLu,OwnHydro) $OwnHydro
	    set Hydrophobicity($NomLu,Hydro) $Hydro
	}
	set Hydrophobicity(EstChargee) 1
	return [Hydrophobicity $Nom $Quoi]
    }

    if { ! [OuiOuNon "Do I calculate all hydrophobicities ?"]} {
	set Hydrophobicity(EstChargee) 1
	return [Hydrophobicity $Nom $Quoi]
    }

    foreach PAB [ListeDesPABs] {
	set Texte [Hydrophobicities $PAB]
	if {$Texte==""} {
	    set Hydro    -2
	    set SonHydro -2
	    set nHelices -2
	} else {
	    foreach Ligne [split [Hydrophobicities $PAB] "\n"] {
		if {[regexp "\[ \t\]$PAB\[ \t\]+" $Ligne]} {
		    scan $Ligne "%s %f %f %d %d" Bidon SonHydro P Long nHelices
		}
		if {[regexp "^GES " $Ligne]} { scan $Ligne "%s %f" Bidon Hydro }
	    }
	}
	set Hydrophobicity($PAB,OwnHydro) $SonHydro
	set Hydrophobicity($PAB,Hydro) $Hydro
	set Hydrophobicity($PAB,nHelices) $nHelices
	lappend LesHydros "$PAB $nHelices $Hydro $SonHydro"
    }
    SauveLesLignes $LesHydros dans $FichierHydrophobicity
    return [Hydrophobicity $Nom $Quoi]
}

proc Hydrophobicities {Fichier {DuParalogue ""}} {
    global RepertoireDuGenome

    if {$DuParalogue==""} {
	set Rep "$RepertoireDuGenome/msf"
    } else {
	set Rep "$RepertoireDuGenome/msfparalogues"
    }

    set Nom [file tail $Fichier]
    if { ! [file exists $Fichier]} { set Fichier "$Rep/$Nom" }
    if { ! [file exists $Fichier]} { return {} }

    if {[catch {set Texte [eval exec "gesscale $Fichier -v"]} Message]} {
	return ""
    }
    return $Texte
}

proc AfficheLesDescriptifs {Source {Ordre "MemeOrdre"} {QuoiRetourner ""} {LesAccessOrdonnes ""} {LesClefs ""} {NomOrigine ""}} {
    #rR Source can be Texte, a file or descriptif/Nom msf/Nom rsf/Nom blast/Nom etc.
    #rR il y a une petite confusion a regler pour LesAccessOrdonnees

    #rR attention je croyais que ca marcherait si on donne une source qui n'est pas du même projet !!!
    #rR ca ne marche pas si on prend MemeOrdre qu'un fichier Macsim par exemple car LeDescriptif est trop spécfique au projet Gscope :'( A VOIR  

    Wup "Attention: blast doesn't rearrange the order of the file"

    if {[regexp "\n" $Source]} {
	set TmpMSF "[TmpFile].msf"
	Sauve $Source dans $TmpMSF
	set NomOuFichier $TmpMSF
    } else {
	set NomOuFichier $Source
	while {[FileAbsent $NomOuFichier]} {
	    set Possible "[RepertoireDuGenome]/$NomOuFichier"
	    if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
	    if {[EstUnPAB $NomOuFichier]} {
		#rR on priviligie le MSF
		set Possible "[RepertoireDuGenome]/msf/$NomOuFichier"
		if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
	    }
	    if {[regexp "rsf" $NomOuFichier]} {
		set Queue [file tail $NomOuFichier]
		set Possible "[RepertoireDuGenome]/macsimRsf/$Queue"
		if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
	    }
	    FaireLire "I can not find $NomOuFichier"
	    return ""
	}
    }

    if {$NomOrigine==""} { set NomOrigine $NomOuFichier }
    set Nom [file tail $NomOrigine]

    set RepDesc "[RepertoireDuGenome]/descriptifs"
    set PossibleRepDesc "[file dirname [file dirname $Source]]/descriptifs"
    if {[file exists $PossibleRepDesc/$Nom]} { set RepDesc $PossibleRepDesc }

    if { 0 && [regexp "/" $NomOuFichier] && [file exists $NomOuFichier]} {
	#rR a mis 0 ... 20150521 ..................................................... ca merde ... si le projet n'est pas le RepertoireDuGenome
	set FichierDescriptif $NomOuFichier
    } else {
	set FichierDescriptif "$RepDesc/$Nom"
    }
    set FichierModele "NeDoitPasExister"

    if {[FileAbsent $FichierDescriptif]} { return "" }

    if {$Ordre=="Natif"} { set LesDes [LesLignesDuFichier $FichierDescriptif] ; set NomOuFichier $FichierDescriptif }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "msf|clustal" $NomOuFichier]} {
	DecortiqueUnMSF $NomOuFichier LesAccessOrdonnes
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "rsf" $NomOuFichier]} {
	DecortiqueUnRSF $NomOuFichier LesAccessOrdonnes
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "blast" $NomOuFichier]} {
	DecortiqueBlast $NomOuFichier 0.001 "SansLimiteDeNombre" Query lBA LesAccessOrdonnes lDE lProfil lPN
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "aliinout" $NomOuFichier]} {
	set LesAccessOrdonnes [LesAccessDuAliInOut $NomOuFichier]
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "disphy" $NomOuFichier]} {
	set LesAccessOrdonnes [FromDisphy $NomOuFichier]
    }
    if {$Ordre=="MemeOrdre" && [regexp -nocase "apns" $NomOuFichier]} {
	set LesAccessOrdonnes [LesAccessDuAPN $NomOuFichier]
    }
    if {[info exists LesAccessOrdonnes] && $LesAccessOrdonnes!=""} {
	if { ! [info exists lBA]} { set lBA $LesAccessOrdonnes }
	foreach Access $LesAccessOrdonnes BA $lBA {
	    set Des [LeDescriptif $Access $Nom]
	    if {[regexp "no description" $Des]} {
		regsub {^PDB_} $BA "PDB:" BA
		set Des [LeDescriptif $BA $Nom]
	    }
	    if {[regexp "no description" $Des]} {
		regsub {^[^\:]+:} $BA "" BA
		set Des [LeDescriptif $BA $Nom]
	    }
	    lappend LesDes $Des 
	}
    } else {
	set LesDes [LesLignesDuFichier $FichierDescriptif]
    }
    foreach Descriptif $LesDes {
	set BeauDes [MiseEnPageDuDescriptif $Descriptif $LesClefs]
	lappend LesBeauxDes $BeauDes
    }

    if {[info exists TmpMSF] && [file exists $TmpMSF]} { file delete -force $TmpMSF }

    if { $QuoiRetourner == "PourGif" } {
	return [join $LesBeauxDes "\n"]
    } elseif { $QuoiRetourner == "LaListe" } {
	return $LesBeauxDes
    } else {
	return [AfficheVariable [join $LesBeauxDes "\n"] "GrandeLargeurAvecAligneurs" $NomOrigine] 
    }
}

proc AfficheLesDescriptifsDuMSF NomOuFichier  {
    global LesDescriptifs

    set Nom [file tail $NomOuFichier]
    if {[regexp "/" $NomOuFichier] && [file exists $NomOuFichier]} {
	set Fichier $NomOuFichier
    } else {
	set Fichier "[RepertoireDuGenome]/msf/$Nom"
    }
    if { ! [file exists $Fichier]} { return "" }

    set MSFdesCopains [expr [OnTraiteUneCollection] && [YaPABdans $Nom]]

    set LesAccess {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp "//" $Ligne]} { break }
	if { ! [regexp "Name\:" $Ligne]} { continue }
	scan $Ligne "%s %s" Name Access
	if {[info exists LesDescriptifs($Access)]} { continue }
	lappend LesAccess $Access
    }
    if {$LesAccess!={} && ! $MSFdesCopains} {
	PrepareLesSequencesDesBanques $LesAccess $LesAccess
    }
    set AuMoinsUneDescription 0
    foreach Access $LesAccess {
	if {[info exists LesDescriptifs($Access)]} {
	    set Descriptif [set LesDescriptifs($Access)]
	} else {
	    if {0 && $MSFdesCopains} {
		set LesLignesEMBL [split [CoCherche "embl" $Nom $Access] "\n"]
	    } else {
		set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"]
	    }
	    if {$LesLignesEMBL=={} } {
		lappend Liste "$Access (no description)"
		continue
	    }
	    DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
	    set Descriptif "$Access OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX: $OX"
	    set LesDescriptifs($Access) $Descriptif
	}
	lappend Liste [MiseEnPageDuDescriptif $Descriptif]
	set AuMoinsUneDescription 1
    }

    if { ! $AuMoinsUneDescription || ! [info exists Liste]} { return "" }

    return [AfficheVariable [join $Liste "\n"] "AvecAligneurs" $Fichier]
}

proc LeDescriptifDuPAB Nom {
    set OS [NotreOS]
    set OC [NotreOC]
    set OX [NotreOX]
    set DE [Definition $Nom]
    set GN [NomDeGene $Nom]
    set ID $Nom
    set AC $Nom

    set Descriptif "$Nom OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX" 
    return $Descriptif
}

proc LeDescriptif {Access {Nom ""} {Texte ""}} {
    global LesDescriptifs
    global NomDesDescriptifsEnMemoire
    Wup "if Texte isn't empty it returns the old value and sets the new one"

    if {$Texte!=""} {
	if {[info exists LesDescriptifs($Access)]} {
	    set Old [set LesDescriptifs($Access)]
	    set LesDescriptifs($Access) $Texte
	    set LesDescriptifs([string toupper $Access]) $Texte
	    return $Old
	}
    }
    if {[info exists LesDescriptifs($Access)]} { return [set LesDescriptifs($Access)] }
    set FichierDescriptif "[RepertoireDuGenome]/descriptifs/$Nom"
    if {$Nom!="" && [file exists $FichierDescriptif]} {
	if {[info exists NomDesDescriptifsEnMemoire] && $NomDesDescriptifsEnMemoire==$Nom} {
	    return "$Access (no description available in descriptifs/$Nom)"
	}
	set LesDescriptifs(${Nom}_isloaded) $Nom
	if {[info exists LesDescriptifs]} { unset LesDescriptifs }
	set LeDescDuPAB [LeDescriptifDuPAB $Nom]
	set LesDescriptifs($Nom) $LeDescDuPAB
	foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
	    set iEgal    [string first "=" $Ligne]
	    set AccessLu [string range $Ligne 0 [expr $iEgal -1]]
	    set Descript [string range $Ligne [expr $iEgal +1] end]
	    set LesDescriptifs($AccessLu)                  $Descript
	    set LesDescriptifs([string toupper $AccessLu]) $Descript
	    set Id [StringApres "ID:" dans $Ligne]
	    set ID [string toupper $Id]
	    regsub $AccessLu $Descript $Id Descript
	    if { ! [info exists LesDescriptifs($Id)] } { set LesDescriptifs($Id) $Descript } 
	    if { ! [info exists LesDescriptifs($ID)] } { set LesDescriptifs($ID) $Descript } 
	}
	set NomDesDescriptifsEnMemoire $Nom
	if {$Texte!=""} {
	    #rR attention le descriptif du Id n'est pas mis à jour !!!!!!!!!!!
	    if {[info exists LesDescriptifs($Access)]} {
		set Old [set LesDescriptifs($Access)]
		set LesDescriptifs($Access) $Texte
		set LesDescriptifs([string toupper $Access]) $Texte
		return $Old
	    }
	}
	if {[info exists LesDescriptifs($Access)]} { return [set LesDescriptifs($Access)] }
	if {$Nom==$Access} { return [LeDescriptifDuPAB $Nom] }
	return "$Access (no description)"
    }
}

proc StockeLeDescriptif {Access Texte {PourQui ""}} {
    global LesDescriptifs

    if { ! [regexp "^file_" $PourQui] && [YaPABdans $PourQui]} {
	set RepDesc "[RepertoireDuGenome]/descriptifs"
	if { ! [file exists $RepDesc]} { File mkdir $RepDesc }
	set Nom $PourQui
	Wup "It does not yet exist or has an other value"
	if {[LeDescriptif $Access $Nom $Texte]!=$Texte} {
	    return [AppendAuFichier "$RepDesc/$Nom" "$Access=$Texte"]
	}
	return "$RepDesc/$Nom"
    }

    if {$PourQui==""} {
	puts stdout "$Access=$Texte"
	return 
    }
    if {[regexp "file_" $PourQui]} {
	 regsub "file_" $PourQui "" Fichier
	return [AppendAuFichier $Fichier "$Access=$Texte"]
    }
    if {[regexp "itself_?" $PourQui]} {
	set Descriptif "$Access=$Texte"
	return [MiseEnPageDuDescriptif $Descriptif]
    }
    return 
}

proc MiseEnPageDuDescriptif {Descriptif {LesClefs ""}} {

    set Texte $Descriptif

    set ID ""
    scan $Texte "%s" ID

    if {[regexp {^[^ ]+=} $Texte]} {
	set iEgal [string first "=" $Texte]
	set Texte [string range $Texte [incr iEgal] end]
    }

    set OX [ChampDuDescriptif $Descriptif OX]
    if {[regexp " " $OX]} { regsub {OS\:} $Texte "OS: $OX " Texte } 

    set LesClefsDefaut {  OS GN DE  ID AC OC OX}
    set IncrementsDefaut {30 15 150 15 15 120 10} 
    set NouvelleManiere 0
    if {$LesClefs=={}} {
	set LesClefs   $LesClefsDefaut
	set Increments $IncrementsDefaut
    } else {
	set NouvelleManiere 1
	set Increments {}
	foreach C $LesClefs {
	    set i [lsearch $LesClefsDefaut $C]
	    lappend Increments [lindex $IncrementsDefaut $i]
	}
    }

    if {$NouvelleManiere} {
	set Texte [format "%-15s" $ID]
	foreach Clef $LesClefs Increment $Increments {
	    set Valeur [ChampDuDescriptif $Descriptif $Clef]
	    append Texte "\t$Clef:[format %-${Increment}s $Valeur]"
	}
	return $Texte
    }
    set BonnePosition 0
    foreach Clef $LesClefs Increment $Increments {
	incr BonnePosition $Increment
	set Position [string first "$Clef\:" $Texte]
	if {$Position < 0} { return $Texte }
	if {$Position < $BonnePosition} {
	    set Debut [string range $Texte 0 [expr $Position-1]]
	    set Suite [string range $Texte [expr $Position] end]
	    set Blanc [string repeat " " [expr $BonnePosition-$Position-1]]
	    set Texte "$Debut$Blanc$Suite"
	}
    }
    return $Texte
}

proc ChampDuDescriptif {Descriptif Clef} {
    if {$Descriptif==""} { return "" }
    set iClef [string first "$Clef:" $Descriptif]
    if {$iClef<0} { return "" }
    set iSuivant [string first ":" [string range $Descriptif [incr iClef 3] end]]
    if {$iSuivant<0} {
	set iSuivant end
    } else {
	incr iSuivant [expr $iClef-3]
    }
    return [string trim [string range $Descriptif $iClef $iSuivant]]
}

proc GardeQueLesMinusculesDesDescriptifs {} {
    Wup "Avant les descriptifs etaient essentiellement en majuscule"
    Wup " S'il y a conflit ... je ne garde que le minuscule."

    set OldAccess ""
    set OldLigne ""
    foreach Ligne [LesLignesDuFichier "lesdescriptifs"] {
	set iEgal [string first "=" $Ligne]
	set Access [string range $Ligne 0 [incr iEgal -1]]
	set Descriptif [string range $Ligne [incr iEgal 2] end]
	if {$OldAccess==$Access} {
	    set OldLigne ""
	}
	if {$OldLigne!=""} {
	    lappend BonnesLignes $OldLigne
	}
	set OldAccess ""
	set OldLigne $Ligne
	set OldAccess $Access
	set OldDescriptif $Descriptif
    }
    if {$Ligne!=""} {
	lappend BonnesLignes $Ligne
    }

    SauveLesLignes $BonnesLignes dans "lesdescriptifs.nouveau"
}

proc DecrisLaLigne {W x y {Efface ""}} {

    regsub ".list" $W ".message" M
    catch {destroy $M}

    if {$Efface!=""} {
	return ""
    }

    set Ligne [$W get @$x,$y]
    
    set Access ""
    set AccessBis ""
    scan $Ligne "%s %s" Access AccessBis

    set Descr [LeDescriptif $Access]
    if {$Descr=="" || [regexp "no description" $Descr]} {
	set Descr [LeDescriptif $AccessBis]
    }
    if {$Descr=="" || [regexp "no description" $Descr]} { return "" }

    set OX [ChampDuDescriptif $Descr OX]
    if {[regexp " " $OX]} {
	foreach TaxId [split $OX " "] {
	    set OS [Tax $TaxId]
	    append Descr "($TaxId=$OS )"
	}
    }

    regsub -all {[A-Z][A-Z]:} $Descr "\n& " Texte

    message $M -borderwidth 3 -font {Courier 10} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
    place $M -x 10 -y $y -anchor w
}

proc MDScoreAvecSelectionDuFichier {FichierMSF LesAccess {InOut "In"}} {
    return [MDScoreAvecSelection [ContenuDuFichier $FichierMSF] $LesAccess $InOut]
}

proc MDScoreAvecSelection {TexteMSF LesAccess {InOut "In"}} {
    if {[llength $LesAccess]<2} { return  -9999.0 }
    set MSFSelection [MSFSelection $TexteMSF $LesAccess $InOut]
    if {$MSFSelection==""} { return -9999.0 }
    return [MDScore $MSFSelection "IsText"]
} 

proc NormdEnStock {Nom {Rep ""}} {
    regsub "blastp" $Rep "" Rep
    #rR on suppose que tous les Normd on deja ete calcules pour chaque type d'alignement correspondant à Rep
    #rR march surtou pour CilioCode, attention a adapter pour les autres
    global NormdEnStock
    if {[info exists NormdEnStock($Nom,$Rep)]}   { return $NormdEnStock($Nom,$Rep) }
    if {[info exists NormdEnStock("EstCharge")]} { return -8888.8 }
    set NormdEnStock("EstCharge") 1
    foreach FichierNormd [glob -nocomplain "[Fiches]/md_scores*"] {
	set Q [file tail $FichierNormd]
	regsub {md_scores\.?} $Q "" R
	foreach Ligne [LesLignesDuFichier $FichierNormd] {
	    scan $Ligne "%s %s" N V
	    set NormdEnStock($N,$R) $V
	}
    }
    return [NormdEnStock $Nom $Rep]
	
}

proc NormdPourTous {{Force ""}} {
    return [Normd "LaListeMerci" $Force]
}


proc Normd {MSFouNom {Force ""}} {
    return [MDScore $MSFouNom $Force]
}

proc MDScore {MSFouNom {Force ""}} {
    global MDScore
    global RepertoireDuGenome
    
    Wup "Force can be CalculeMoi  or IsText if MSFouNom is the text of the MSF itself"
    
    if {$Force=="IsText"} {
	set MSF $MSFouNom
	set FichierMSF [TmpFile]
	Sauve $MSF dans $FichierMSF
	set Nom ""
	set Force "CalculeMoi"
    } else {
	set Nom $MSFouNom
	if {$Nom=="LaListeMerci" && [info exists MDScore("LaListeMerci")]} {
	    return [set MDScore("LaListeMerci")]
	}
	set FichierMSF $Nom
	set Nom [file tail $FichierMSF]
    }
    
    set CalculeMoi [string equal -nocase "CalculeMoi" $Force]
    
    if { ! $CalculeMoi && $Nom!="" && [info exists MDScore($Nom)]} { return [set MDScore($Nom)] }
    
    if { ! [file exists $FichierMSF]} {
	set FichierMSF "$RepertoireDuGenome/msf/$Nom"
    }
    
    if { $Nom!="LaListeMerci" && ($CalculeMoi || ! [YaPABouTROUouTRNAouARNenDebutDe $Nom])} {
	set CommandeMDScore "normd $FichierMSF"
	set MD ""
	if { ! [catch {set MD [eval exec $CommandeMDScore]} Message]} {
	    if { ! [regexp {[0-9]} $MD]} {
		Warne "MDScore ne rend pas de nombre mais $Message"
		return -9999.4
	    }		
	    set Score ""
	    scan $MD "%s %f" NomDuFich Score
	    if {[regexp {^[0-9\-\+\.eE]+$} $Score]} {
		set MD $Score
	    } elseif {[regexp {^[0-9\-\+\.eE]+$} $NomDuFich]} {
		set MD $NomDuFich
	    } else {
		set MD $MD
	    }
	    return $MD
	} else {
	    Warne "MDScore se plante par $Message"
	    return -9999.0
	}
    }
    set FichierMDs "$RepertoireDuGenome/fiches/md_scores"
    if {[file exists $FichierMDs] && [ContenuDuFichier $FichierMDs]!=""} {
	foreach Ligne [LesLignesDuFichier $FichierMDs] {
	    set MD ""
	    scan $Ligne "%s %s %s" NomLu MDouFichier MD
	    if {$MD==""} { set MD $MDouFichier }
	    if {$MD==""} { set MD -9999.5 }
	    set MDScore($NomLu) $MD
	    lappend MDScore(LaListeMerci) "$NomLu $MD"
	}
	if {[info exists MDScore($Nom)]} {
	    return [set MDScore($Nom)]
	} else {
	    if {$Force=="CalculeMoiSiManquant"} {
		set MD [MDScore $Nom "CalculeMoi"]
		lappend MDScore(LaListeMerci) "$Nom $MD"
		set LesNomMD [lsort [set MDScore(LaListeMerci)]]
		SauveLesLignes $LesNomMD dans $FichierMDs
		return $MD
	    }
	    return -9999.8
	}
    }
    
    if { ! [OuiOuNonMemo "Do I calculate now all MDscores (NorMD) ... ?"]} { return -9999.3 }
    
    foreach NomLu [ListeDesPABs] {
	if {[info exists MDScore($NomLu)]} { continue }
	set FichierMSF "$RepertoireDuGenome/msf/$NomLu"
	if { ! [file exists $FichierMSF] } {
	    set MD -9999.7
	} elseif { [regexp -nocase "NoSequencesToAlign" [ContenuDuFichier $FichierMSF]] } {
	    set MD -9999.7
	} else {
	    set MD [MDScore $FichierMSF "CalculeMoi"]
	}
	set MDScore($NomLu) $MD
	Espionne "$NomLu $MD"
	AppendAuFichier $FichierMDs "$NomLu $MD"
    }
    if {[info exists MDScore($Nom)]} {
	return [set MDScore($Nom)]
    } else {
	return -9999.6
    }
}

proc FichierMiniConfig {} {
    global RepertoireDuGenome
    return "$RepertoireDuGenome/beton/miniconfig"
}

proc FichierBlastPDuPAB Nom {
    global RepertoireDuGenome
    return "$RepertoireDuGenome/blastp/$Nom"
}

proc LesDefinitionsRevisitees {} {
    foreach Nom [ListeDesPABs] {
	set NotreDE [string trim [Definition $Nom] "."]
	set NarciDE [string trim [ExtraitInfo $Nom "DE_Narcisse"] "."]
	if {[string toupper $NotreDE]==[string toupper $NarciDE]} { continue }
	if {[regexp "Hypothetical protein" $NotreDE] \
		&& [regexp {HYPOTHETICAL [0-9\.]* KDA PROTEIN} $NarciDE] } { continue } 
	Espionne $Nom
	Espionne "$NotreDE\n$NarciDE"
	lappend LesNouveaux $Nom
    }
    return $LesNouveaux
}

proc LaManierePourAffiche TypeDeFichier {
    set PourNotes 0
    set PourNuc   0
    set PourProt  0
    set PourBlast 0
    set PourMSF   0

    set Rep [file tail [file dirname $TypeDeFichier]]

    if {[regexp -nocase {^notes}    $Rep]} {
	set PourNotes 1
    }
    if {[regexp -nocase {^(copain|tfa)}    $Rep]} {
	set PourNuc 1
    }
    if {[regexp -nocase {nuctfa|nucembl}   $Rep]} {
	set PourNuc 1
    }
    if {[regexp -nocase {prottfa|protembl} $Rep]} {
	set PourProt 1
    }
    if {[regexp -nocase {(TBlast|Blast|Ballast)} $Rep]} {
	set PourBlast 1
    }
    if {[regexp -nocase {(MSF|Clustal|DbClustal)} $Rep]} {
	set PourMSF 1
    }

    set LesAvecs {}
    if {$PourNuc}   { lappend LesAvecs "AvecBlaste" "AvecFormate"}
    if {$PourProt}  { lappend LesAvecs "AvecBlaste" "AvecFormate"}
    if {$PourBlast} { lappend LesAvecs "AvecAligneurs" "AvecSegAlignements" }
    if {$PourMSF}   { lappend LesAvecs "AvecEtudeMSF" "GrandeLargeur"}
    if {[OnTraiteDesClones]} {
	if {$PourNotes} {
	    lappend LesAvecs "AvecOli"
	    lappend LesAvecs "AvecShowItsOligos"
	}
    }
    set LesAvecs [lsort -unique $LesAvecs]
    return [join $LesAvecs ""]    
}

proc PourcentageDeStops {} {
    global RepertoireDuGenome

    Wup "Ecrit pour Philippe Dumas, pour trouver les codons stop en frame shift dans chaque prot"

    set CumulFavorable(1) 0
    set CumulFavorable(2) 0
    set CumulPossible(1) 0
    set CumulPossible(2) 0
    set nSansRien 0
    set MaxVoulus -1
    foreach Nom [ListeDesPABs] {
	if { ! [incr MaxVoulus -1]} { break }
	set Debut  [Box $Nom debut]
	set Fin    [Box $Nom fin]
	set Orient [Box $Nom orient]
	set Seq [BoutADN $Debut $Fin $Orient]
	set Long [string length $Seq]
	foreach Decalage {1 2} {
	    set nStops 0
	    set nCodons 0
	    set nSansRien 0
	    for {set i $Decalage} {$i < [expr $Long-3]} {incr i 3} {
		incr nCodons
		incr CumulPossible($Decalage)
		set Codon [string range $Seq $i [expr $i+2]]
		if {[CodonStopPossible $Codon]} {
		    incr CumulFavorable($Decalage)
		    incr nStops
		    if {$nSansRien>0} {
			lappend LesSansRien($Decalage) $nSansRien
		    }
		    set nSansRien 0
		} else {
		    incr nSansRien
		}
	    }
	    set Pourcent($Decalage) [expr 100.*$nStops/$nCodons]
	}
#	Espionne "$Nom [format "%4.1f" $Pourcent(1)] [format "%4.1f" $Pourcent(2)]"	
    }
    Histogramme [set LesSansRien(1)] "Graphe"
    Histogramme [set LesSansRien(2)] "Graphe"
    Espionne "$CumulFavorable(1) / $CumulPossible(1)    $CumulFavorable(2) / $CumulPossible(2)"
    Espionne "[format "%4.1f" [expr 100.*$CumulFavorable(1)/$CumulPossible(1)]]  [format "%4.1f" [expr 100.*$CumulFavorable(2)/$CumulPossible(2)]]"
    return 
}

proc VraisParaloguesDe Nom {
    global VraisParaloguesDe
    global RepertoireDuGenome

    set SeuilParalogue 20

    if {[info exists VraisParaloguesDe($Nom)]} { return [set VraisParaloguesDe($Nom)] }
    if {[info exists VraisParaloguesDe]} { return {} }

    set FichierVraisParalogues "$RepertoireDuGenome/fiches/paralogues"
    if {[file exists $FichierVraisParalogues]} {
	foreach Ligne [LesLignesDuFichier $FichierVraisParalogues] {
	    set LesParas [split $Ligne " "]
	    set NomLu [lindex $LesParas 0]
	    lappend LesNoms $NomLu
	    set VraisParaloguesDe($NomLu) [lrange $LesParas 1 end] 
	}
	set VraisParaloguesDe(LaListeMerci) $LesNoms
	if {[info exists VraisParaloguesDe($Nom)]} { return [set VraisParaloguesDe($Nom)] }
	return {}
    }
    
    
    set PICPar "$RepertoireDuGenome/fiches/piclustalw.paralogues"
    if { ! [file exists $PICPar]} {
	FaireLire "Please create the paralogues with AlignonsLesParalogues"
	set VraisParaloguesDe(LaListeMerci) {}
	return {}
    }
    foreach Ligne [LesLignesDuFichier $PICPar] {
	set Liste [split $Ligne " "]
	set NomLu [lindex $Liste 0]
	set LesParas {}
	foreach {Para PIC} [lrange $Liste 1 end] {
	    if {$Para==$NomLu} { continue }
	    if { $PIC < $SeuilParalogue } { break }
	    lappend LesParas $Para
	}
	if {$LesParas=={}} { continue }
	lappend LesLignes "$NomLu [join $LesParas " "]"
    }
    SauveLesLignes $LesLignes dans $FichierVraisParalogues
    return [VraisParaloguesDe $Nom]
}

proc tnal {} {
   CreationDuNalDesGenomesComplets "pfur" "dmel|worm" "Pfuriosus" 
}

proc OrganismeDeLaBanqueBlastN {{Qui ""} {Quoi ""}} {
    global OrganismeDeLaBanqueBlast

    if {$Qui=="" && $Quoi==""} { set Qui "ListOf" ; set Quoi "Files" }
    if { ! [regexp -nocase "Banks|Bank|Organisms|Organism|Files" $Quoi]} {
	if {$Quoi==""} {
	    if {[regexp " " $Qui]} { set Quoi "Bank" } else { set Quoi "Organism" }
	} else {
	    set Qui "$Qui $Quoi"
	    set Quoi "Bank"
	}
    }

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

    foreach FichierNal [lsort [glob -nocomplain "/catalog/blast/*.nal"]] {
	set Queue [file tail $FichierNal]
	regsub {\.nal$} $Queue "" Banque
	set Organisme ""
	foreach Ligne [LesLignesDuFichier $FichierNal] {
	    if { ! [regexp -nocase {^ *TITLE +Genome complet *\- *} $Ligne]} { continue }
	    regsub -nocase {^ *TITLE +Genome complet *\- *} $Ligne "" Organisme
	    break
	}
	if {$Organisme==""} { continue }
	if {[regexp "_" $Banque]} {
	    regsub "_" $Banque " " BO
	    if {$BO!=$Organisme} { FaireLire "$Organisme\n$Ligne\n$FichierNal" }
	}
	if {[info exists OrganismeDeLaBanqueBlast($Banque,Organism)]} {
	    FaireLire "Doublon $Organisme $Banque\n$Ligne\n$FichierNal" 
	}
	set OrganismeDeLaBanqueBlast($Banque,Organism) $Organisme

	if { ! [info exists OrganismeDeLaBanqueBlast($Organisme,Bank)]} { 
	    set OrganismeDeLaBanqueBlast($Organisme,Bank) $Banque
	} else {
	    if {[regexp "_" $Banque]} { set OrganismeDeLaBanqueBlast($Organisme,Bank) $Banque }
	}

	lappend OrganismeDeLaBanqueBlast(ListOf,Files) $FichierNal
	lappend OrganismeDeLaBanqueBlast(ListOf,Organisms) $Organisme
	lappend OrganismeDeLaBanqueBlast(ListOf,Banks) $Banque
    }
    return [OrganismeDeLaBanqueBlastN $Qui $Quoi]
}

proc CreationDuNalDesGenomesComplets {{Indesirables ""} {SuppOfficielles ""} {SuppGscope ""}} {
    global RepertoireDuGenome

    set RepertoireOfficiel "/catalog/blast"
    set LienLocal "blast"

    if { ! [file exists "$RepertoireDuGenome/banques"]} { File mkdir "$RepertoireDuGenome/banques" }

    while { ! [file exists "$RepertoireDuGenome/banques/blast"]} {
	if {[OuiOuNon "I need a link $RepertoireOfficiel -> $RepertoireDuGenome/banques/$LienLocal\n \
		Can I do it ? "]} {
	    eval exec "ln -s $RepertoireOfficiel $RepertoireDuGenome/banques/$LienLocal"
	} else {
	    if {[OuiOuNon "Do I skipp this now (You can fix it later) ?"]} { break }
	    if {[OuiOuNon "Do I cancel the Nal-blastn-database creation ?"]} { return }
	    if {[OuiOuNon "Do I exit Gscope ?"]} { exit }
	}	    
    }
    set FichierNal "$RepertoireDuGenome/banques/completegenomes.nal"

    if {[OuiOuNon "Do you want to use the new version (2007/12/20) ?"]} {
	set LeNal {}
	foreach Genome [LesGenomesComplets] {
	    regsub " " $Genome "_" G
	    set RG "/catalog/blast/$G"
	    if {[file exists "$RG.nal"]} {
		lappend LeNal $RG
		continue
	    }
	    set RG [Entre $RG]
	    if {$RG ==""} { continue }
	    lappend LeNal $RG
	}
	set LeTexte {}
	lappend LeTexte "# Alias file created by Gscope"
	lappend LeTexte "#"
	lappend LeTexte "TITLE \"Complete Genomes created by Gscope [Date Nice]\""
	lappend LeTexte "#"
	lappend LeTexte "DBLIST [join $LeNal " "]"
	SauveLesLignes $LeTexte dans $FichierNal
	return $FichierNal    
    }

    set NalOfficiel "$RepertoireOfficiel/genomes.nal"
    
    foreach IS {"Indesirables" "SuppOfficielles" "SuppGscope"} \
	    Action {"remove" "add" "add (from Gscope)"} \
	    Defaut {"llact" \
	    "/catalog/blast/dmel|/catalog/blast/worm|/catalog/blast/spombe|/catalog/blast/ecuniculi|/catalog/blast/yeast|/catalog/blast/athaliana" \
	    "Mkan"} {
	if {[set $IS] != "PleaseAsk"} { continue }
	if {[OuiOuNon "Do You want to $Action some genomes in $NalOfficiel ? "]} {
	    FaireLire "Please give their names (BUT NOT human NOR mouse) (see in $NalOfficiel)"
	    set $IS [Entre $Defaut]
	    regsub -all {\|} [set $IS] " " $IS
	    while {[regexp "  " [set $IS]]} { regsub -all "  " [set $IS] " " $IS }
	    regsub -all " " [set $IS] "|" $IS
	} else {
	    set $IS ""
	} 
	Espionne "$IS [set $IS]"
    }

    set LesIndesirables    [split $Indesirables    "|"]
    set LesSuppOfficielles [split $SuppOfficielles "|"]
    set LesSuppGscope      [split $SuppGscope      "|"]

    Espionne $LesIndesirables
    Espionne $LesSuppOfficielles

    set LesBanquesOfficielles {}
    foreach Ligne [LesLignesDuFichier $NalOfficiel] {
	if { ! [regexp -nocase "^DBLIST" $Ligne]} { continue }
	
	set LesBanquesOfficielles [concat $LesBanquesOfficielles [lrange [split $Ligne " "] 1 end]]
    }

    foreach Banque $LesBanquesOfficielles {
	if { ! [regexp -nocase {[a-z]} $Banque]} { continue }
	if { [lsearch -exact $LesIndesirables $Banque] > -1 } { continue }
	lappend LesBonnesBanquesOfficielles "$LienLocal/$Banque"
	lappend LesVraiesBanques $RepertoireOfficiel/$Banque
    }
    foreach BanqOff $LesSuppOfficielles {
	if { ! [file exists "$BanqOff.nhr"] && ! [file exists "/catalog/blast/$BanqOff.nhr"]} {
	    if {[OuiOuNon "$BanqOff.nhr doesn't exist ... Do I skip it ?"]} { continue }
	}
	set Banque [file tail $BanqOff]
	lappend LesBonnesBanquesOfficielles "$LienLocal/$Banque"
	lappend LesVraiesBanques $BanqOff 
    }
    set LesBonnesBanquesANous {}
    foreach RepGenome $LesSuppGscope {
	if { ! [regexp "/" $RepGenome]} {
	    set Prefixe [PrefixeDuGenome $RepGenome]
	    set Banque "../../$RepGenome/banques/${Prefixe}overlap"
	}
	set BonneBanque 1
	set VraieBanque "$RepertoireDuGenome/banques/$Banque"
	while { ! [file exists "$VraieBanque.nhr"] } {
	    if {[OuiOuNon "$VraieBanque\n doesn't exist.\n \
		    (Maybe you can create it later with\n   \
		      setgscope $RepGenome\n   \
		      gscope CreeLaBanqueBlastN\n \
		     It's easy.)\n \
		    Do I keep it now as it is ?"]} { break }
	    if {[OuiOuNon "the tfa file of $VraieBanque\n doesn't exist. Do I skipp it ?"]} {
		set BonneBanque 0
		break
	    }
	    if {[OuiOuNon "$VraieBanque\n doesn't exist. Do You know how to call it ?"]} {
		set Banque [Entre $Banque]
		set VraieBanque "$RepertoireDuGenome/banques/$Banque"
	    }
	}
	if {$BonneBanque} {
	    lappend LesBonnesBanquesANous $Banque
	    lappend LesVraiesBanques $VraieBanque
	}
    }
    set SuppHuman ""
    set LesHuman {}
    if {[OuiOuNon "Do You want to add the complete human genome ?"]} {
	set SuppHuman "human.nal"
	set LesHuman [LesBanquesDuNal "/catalog/blast/human.nal" "$LienLocal/"]
	foreach HB $LesHuman {
	    lappend LesVraiesBanques $HB
	}
    }
    set SuppMouse ""
    set LesMouse {}
    if {[OuiOuNon "Do You want to add the complete mouse genome ?"]} {
	set SuppMouse "mouse.nal"
	set LesMouse [LesBanquesDuNal "/catalog/blast/mouse.nal" "$LienLocal/"]
	foreach MB $LesMouse {
	    lappend LesVraiesBanques $MB
	}
    }
    set Liste [join [concat $LesBonnesBanquesANous $LesBonnesBanquesOfficielles $LesHuman $LesMouse] " "]
    set Sortie {}
    lappend Sortie "#"
    lappend Sortie "# Alias file for blast database created by Gscope [Date]"
    lappend Sortie "#"
    lappend Sortie "TITLE \"Complete Microbial Genomes without $Indesirables with $SuppOfficielles $SuppGscope $SuppHuman $SuppMouse\""
    lappend Sortie "#"
    lappend Sortie "DBLIST $Liste"
    lappend Sortie "#"
    set FichierNal [SauveLesLignes $Sortie dans "$RepertoireDuGenome/banques/completegenomes.nal"]

    set Hop 0
    set FichierHeaders    "$RepertoireDuGenome/banques/completegenomes.header"
    set FichierCorrection "$RepertoireDuGenome/banques/completegenomes.correction"
    if {[file exists $FichierHeaders] && [OuiOuNon "Do I replace $FichierHeaders ?"]} {
	File delete -force $FichierHeaders
    }
    set nORGinconnu 0
    foreach VraieBanque $LesVraiesBanques {
	Espionne "VraieBanque $VraieBanque"
	set Banque [file tail $VraieBanque]
	set SesHeaders [LesHeadersDeLaBanqueBlast $VraieBanque]
	set H [lindex $SesHeaders 0]
	Espionne "H     $H"
	set ORG [file tail $VraieBanque]
	if { ! [regexp -nocase {^[a-z0-9_]+\:[a-z0-9_]+} $H]} {
	    set ORG "$ORG:"
	    foreach H $SesHeaders {
		scan $H "%s" A
		AppendAuFichier $FichierCorrection "$A $ORG$A" 
		lappend SesNouveauxHeaders "$ORG$H"
		Espionne "I use ${ORG}$A instead of $A (see $FichierCorrection) "
	    }
	    set SesHeaders $SesNouveauxHeaders
	}
	AppendAuFichier $FichierHeaders [join $SesHeaders "\n"]
    }
    return $FichierNal
}

proc ttok {Fonction Fichier} {
    global TokCourant
    global ChaineTok

    set Texte [ContenuDuFichier $Fichier]

    Tok $Texte
    Espionne [$Fonction]
    if {$ChaineTok!=""} { Espionne "${TokCourant}$ChaineTok" }
    exit
}

proc TroisBoots {{Texte ""}} {
    global TokCourant

    if {$Texte!=""} { Tok $Texte }

    if { ! [regexp {^\(} $TokCourant]} { return "TroisBootsNonValideCarSansOuvrante" }
    Tok
    set Gauche [Arboot]
    if {[regexp "NonValide" $Gauche]} { return "TroisBootsNonValideCar$Gauche" }
    if { ! [regexp {\,} $TokCourant]} { return "TroisBootsNonValideCarSansVirgule" }
    Tok
    set Milieu [Arboot]
    if {[regexp "NonValide" $Milieu]} { return "TroisBootsNonValideCar$Milieu" }
    if { ! [regexp {\,} $TokCourant]} { return "TroisBootsNonValideCarSansVirgule" }
    Tok
    set Droite [Arboot]
    if {[regexp "NonValide" $Droite]} { return "TroisBootsNonValideCar$Droite" }
    if { ! [regexp {\)} $TokCourant]} { return "TroisBootsNonValideCarSansFermante" }
    Tok
    if { ! [regexp {\;} $TokCourant]} { return "TroisBootsNonValideCarSansPointVirgule" }
    return [list $Gauche $Milieu $Droite]
    
}

proc Arboot {} {
    global TokCourant
    if { ! [regexp {^\(} $TokCourant]} {
	set FeuilleDist [FeuilleDist]
	if {[regexp "NonValide" $FeuilleDist]} { return "ArbootNonValideCar$FeuilleDist" }
	return $FeuilleDist
    }
    Tok
    set Gauche [Arboot]
    if {[regexp "NonValide" $Gauche]} { return "ArbootNonValideCar$Gauche" }
    if { ! [regexp {\,} $TokCourant]} { return "ArbootNonValideCarSansVirgule" }
    Tok
    set Droite [Arboot]
    if {[regexp "NonValide" $Droite]} { return "ArbootNonValideCar$Droite" }
    if { ! [regexp {\)} $TokCourant]} { return "ArbootNonValideCarSansFermante" }
    Tok
    set ValeurDist [ValeurDist]
    if {[regexp "NonValide" $ValeurDist]} { return "ArbootNonValideCar$ValeurDist" }
    if {[regexp {^\[} $TokCourant]} {
	set ValeurBoot [ValeurBoot]
	if {[regexp "NonValide" $ValeurBoot]} { return "ArbootNonValideCar$ValeurBoot" }
    } else {
	set ValeurBoot 0
    }
    return [list $Gauche $Droite $ValeurDist $ValeurBoot]
}

proc FeuilleDist {} {
    global TokCourant
    set LabelFeuille [AlphaNum]
    if {[regexp "NonValide" $LabelFeuille]} { return "FeuilleDistNonValideCar$LabelFeuille" }
    set ValeurDist [ValeurDist]
    if {[regexp "NonValide" $ValeurDist]} { return "FeuilleDistNonValideCar$ValeurDist" }
    return [list $LabelFeuille $ValeurDist]
}

proc Flottant {} {
    global TokCourant
    
    set Courant ""
    if {[regexp {^\.} $TokCourant]} {
	set Courant "0."
	Tok
    } else {
	set AvantPoint [Entier]
	if {[regexp "NonValide" $AvantPoint]} { return "FlottantNonValideCar$AvantPoint" } 
	set Courant "$AvantPoint."
	if { ! [regexp {^\.} $TokCourant]} {
	    return "FlottantNonValideCarSansPointDecimal"
	}
	Tok
    } 
    if { ! [regexp {^[0-9]} $TokCourant]} { return "${Courant}0" } 
    set ApresPoint [Entier]
    return "${Courant}$ApresPoint"
}

proc AlphaNum {} {
    global TokCourant
    
    set Courant ""
    if {[regexp -nocase {[a-z_]} $TokCourant]} {
	set Courant $TokCourant
    }
    if {$Courant==""} {	return "AlphaNumNonValideCarNonAlphaEnDebut" }
    while {[regexp -nocase {[a-z_0-9]} [Tok]]} {
	append Courant $TokCourant
    }
    return $Courant
}

proc Entier {} {
    global TokCourant
    
    set Courant ""
    if {[regexp {[0-9]} $TokCourant]} {
	set Courant $TokCourant
    }
    if {$Courant==""} {    
	return "EntierNonValideCarNonNumeriqueEnDebut"
    }
    while {[regexp {[0-9]} [Tok]]} {
	append Courant $TokCourant
    }
    return $Courant
}

proc ValeurFeuille {} {
    global TokCourant
    global ValueurFeuille
    if {regexp -nocase {[a-z_]} $TokCourant} {
	set ValeurFeuille $TokCourant
	Tok
	set AlphaNum [AlphaNum]
	if { ! [regexp "NonValide" $AlphaNum]} {
	    append ValeurFeuille $AlphaNum
	}
	return $ValeurFeuille
    }
    return "ValeurFeuilleNonValideCarNonAlphaEnDebut"
}

proc ValeurDist {} {
    global TokCourant
    if {$TokCourant==":"} {
	Tok
	set Flottant [Flottant]
	if {[regexp "NonValide" $Flottant]} { return "ValeurDistNonValideCar$Flottant" }
	return $Flottant
    }	    
    return "ValeurDistNonValideCarNonDoublePoints"
}

proc ValeurBoot {} {
    global TokCourant
    if {$TokCourant=="\["} {
	Tok
	set Entier [Entier]
	if {[regexp "NonValide" $Entier]} { return "ValeurBootNonValideCar$Entier" }
	if {$TokCourant=="\]"} {
	    Tok
	    return $Entier
	}
	return "ValeurBootNonValideCarNonCrochetFermant"
    }	    
    return "ValeurBootNonValideCarNonCrochetOuvrant"
}

proc Tok {{TexteInitial ""}} {
    global ChaineTok
    global TokCourant
    if {$TexteInitial!=""} { set ChaineTok $TexteInitial }
    if { $ChaineTok=="" } { set TokCourant "" ;  return "" }
    set Tok [string index $ChaineTok 0]
    set ChaineTok [string range $ChaineTok 1 end]
    if {[regexp {[ \n\t]} $Tok]} { return [Tok] }
    set TokCourant $Tok
    return $Tok    
}

proc PhyloBreak {{Nom "LaListeMerci"}} {
    global RepertoireDuGenome
    global PhyloBreak PhyloBreakEstCharge

    if {[info exists PhyloBreak($Nom)]} { return [set PhyloBreak($Nom)] }


    if { ! [info exists PhyloBreakEstCharge]} {
	set FichierPhyloBreak "$RepertoireDuGenome/fiches/phylobreak"
	if { ! [file exists $FichierPhyloBreak]} { return "NotAvailable" }
	
	foreach Ligne [LesLignesDuFichier $FichierPhyloBreak] {
	    scan $Ligne "%s" NomLu
	    set PhyloBreak($NomLu) 1
	}
	set PhyloBreakEstCharge "EstCharge"
    }

    if {$Nom=="LaListeMerci"} { return [array names PhyloBreak] }

    if {[info exists PhyloBreak($Nom)]} {
	return [set PhyloBreak($Nom)]
    } else {
	return 0
    }
}

proc TestLesDescriptifs {} {
    global RepertoireDuGenome
    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/lesdescriptifs"] {
	ScanLaListe [split $Ligne "="] AC Reste
#	Espionne "[ChampDuDescriptif [LeDescriptif $AC] OS] \
#		[ChampDuDescriptif [LeDescriptif $AC] OX]"
#	continue 
	ScanLaListe [split $Ligne " "] Bidon OSGenre Espece
	regsub "OS\:" $OSGenre "" Genre
	set Organisme "$Genre $Espece"

	Espionne [time {Getz $AC}]
	Espionne [time {set OS [QuestionDeScience QuidSeq "QuidOSOfAC $AC"]}]
	regsub {^[ \n]|[ \n]$} $OS "" OS 
	if {$OS==$Organisme} {
	    Espionne "$Organisme $AC"
	} else {
	    Espionne "$Organisme $AC >$OS< +++++++++++++++++"
	}
    }
}

proc PourcentageDeGenomesCompletsOrthologuesDansTBlastN Nom {
    global PourcentageDeGenomesCompletsOrthologuesDansTBlastN
    if {[info exists PourcentageDeGenomesCompletsOrthologuesDansTBlastN($Nom)]} {
	return [set PourcentageDeGenomesCompletsOrthologuesDansTBlastN($Nom)]
    }
    if {[info exists PourcentageDeGenomesCompletsOrthologuesDansTBlastN("EstCharge")]} {
	return -1
    }

    foreach NomLu [ListeDesPABs] {
	set Tous [string trim [ORGAorgaDesTBlastNs $NomLu]]
	regsub -all { {2,}} $Tous " " Tous
	set nTous [Maxi 1 [llength [split $Tous " "]]]
	regsub -all {[A-Z]} $Tous "" Absents
	set Absents [string trim $Absents]
	regsub -all { {2,}} $Absents " " Absents
	set nAbsents [llength [split $Absents " "]]
	set PourcentageDeGenomesCompletsOrthologuesDansTBlastN($NomLu) [expr round(($nTous-$nAbsents)*100/$nTous)]
    }
    set PourcentageDeGenomesCompletsOrthologuesDansTBlastN(Count) $nTous
    set PourcentageDeGenomesCompletsOrthologuesDansTBlastN("EstCharge") 1
    return [PourcentageDeGenomesCompletsOrthologuesDansTBlastN $Nom]
}

proc PourcentageDeGenomesCompletsOrthologuesDansDbClustal Nom {
    global PourcentageDeGenomesCompletsOrthologuesDansDbClustal
    if {[info exists PourcentageDeGenomesCompletsOrthologuesDansDbClustal($Nom)]} {
	return [set PourcentageDeGenomesCompletsOrthologuesDansDbClustal($Nom)]
    }
    if {[info exists PourcentageDeGenomesCompletsOrthologuesDansDbClustal("EstCharge")]} {
	return -1
    }

    foreach NomLu [ListeDesPABs] {
	set Tous [string trim [ORGAorgaDesMSFs $NomLu]]
	regsub -all { {2,}} $Tous " " Tous
	set nTous [Maxi 1 [llength [split $Tous " "]]]
	regsub -all {[A-Z]} $Tous "" Absents
	set Absents [string trim $Absents]
	regsub -all { {2,}} $Absents " " Absents
	set nAbsents [llength [split $Absents " "]]
	set PourcentageDeGenomesCompletsOrthologuesDansDbClustal($NomLu) [expr round(($nTous-$nAbsents)*100/$nTous)]
    }
    set PourcentageDeGenomesCompletsOrthologuesDansDbClustal(Count) $nTous
    set PourcentageDeGenomesCompletsOrthologuesDansDbClustal("EstCharge") -1
    return [PourcentageDeGenomesCompletsOrthologuesDansDbClustal $Nom]
}

proc OldPourcentageDeGenomesCompletsOrthologuesDansDbClustal Nom {
    global PourcentageDeGenomesCompletsOrthologuesDansDbClustal
    if {[info exists PourcentageDeGenomesCompletsOrthologuesDansDbClustal($Nom)]} {
	return [set PourcentageDeGenomesCompletsOrthologuesDansDbClustal($Nom)]
    }
    if {[info exists PourcentageDeGenomesCompletsOrthologuesDansDbClustal("EstCharge")]} {
	return -1
    }

    foreach NomLu [ListeDesPABs] {
	set PH [PhylumsOrthologues $NomLu]
	scan $PH "%s %d %d %d %d %d %d" BAE nB mB nA mA nE mE
	set Favorable [expr $nB+$nA+$nE]
	set Possible  [expr $mB+$mA+$mE]
	set PourcentageDeGenomesCompletsOrthologuesDansDbClustal($NomLu) [expr round(($nB+$nA+$nE)*100/($mB+$mA+$mE))]
    }
    set PourcentageDeGenomesCompletsOrthologuesDansDbClustal(Count) $Possible
    set PourcentageDeGenomesCompletsOrthologuesDansDbClustal("EstCharge") -1
    return [PourcentageDeGenomesCompletsOrthologuesDansDbClustal $Nom]
}

proc PhylumsOrthologues {{Nom "LaListeMerci"}} {
    global RepertoireDuGenome
    global PhylumsOrthologues

    set FichierPhylumsOrthologues "$RepertoireDuGenome/fiches/phylumsorthologues"
    if {[info exists PhylumsOrthologues($Nom)]} { return [set PhylumsOrthologues($Nom)] }

    if {[info exists PhylumsOrthologues("EstCharge")]} {
	if {[info exists PhylumsOrthologues($Nom)]} { return [set PhylumsOrthologues($Nom)] }
	if {$Nom=="LaListeMerci"} { return [LesLignesDuFichier $FichierPhylumsOrthologues] }
	return ""
    }

    if {[OnTraiteUneCollection] && [ExtraitInfo [lindex [ListeDesPABs] 0] "BAE"]!=""} {
	foreach NomLu [ListeDesPABs] {
	    set BAE  [ExtraitInfo $NomLu "BAE"]
	    set PhylumsOrthologues($NomLu) $BAE
	    lappend PhylumsOrthologues(LaListeMerci) $BAE
	}
	set PhylumsOrthologues("EstCharge") 1
	if {[info exists PhylumsOrthologues($Nom)]} { return [set PhylumsOrthologues($Nom)] }
	if {$Nom=="LaListeMerci"} { return [set PhylumsOrthologues(LaListeMerci)] }
	return ""	
    }

    Wup "Now we will load FichierPhylumsOrthologues"

    if {[file exists $FichierPhylumsOrthologues]} {
	foreach Ligne [LesLignesDuFichier $FichierPhylumsOrthologues] {
	    scan $Ligne "%s" NomLu
	    regsub "^$NomLu " $Ligne "" Ligne
	    set Ligne [string trim $Ligne]
	    set PhylumsOrthologues($NomLu) $Ligne
	}
	set PhylumsOrthologues("EstCharge") 1
	return [PhylumsOrthologues $Nom]
    }

    Wup "Now We will create FichierPhylumsOrthologues"

    set FichierOoMSF "$RepertoireDuGenome/fiches/oomsf"

    if { ! [file exists $FichierOoMSF]} { return "" }

    foreach OS [LesGenomesDansLeBonOrdre] OC [LesGenomesDansLeBonOrdre OC] {
	set BAE($OS) [string index $OC 0]
    }
    foreach Ligne [LesLignesDuFichier $FichierOoMSF] {
	set Ligne [string trim $Ligne]
	scan $Ligne "%s" Nom
	Wup "C means Class unknown"
	foreach P {B A E C} S {0.5 0.5 0.5 0.5} {
	    set PhylumTouche($P) 0
	    set PhylumTotal($P) 0
	    set SeuilPhylumTouche($P) $S
	}
	foreach Oo [lrange [split $Ligne " "] 1 end] {
	    set Orga [string tolower $Oo]
	    set Complet [Glossaire $Orga Complet]
	    set P ""
	    if {[info exists BAE($Complet)]} {
		set P [set BAE($Complet)]
	    }
	    if {$P==""} { set P "C" }
	    incr PhylumTotal($P)
	    if {[regexp {[A-Z]} $Oo]} { incr PhylumTouche($P) }
	    set T [Maxi [set PhylumTotal($P)] 1]
	    set PourcentagePhylumTouche($P) [expr 1.0*[set PhylumTouche($P)]/$T]
	}
	set TexteBAE ""
	set Resume {}
	foreach P {B A E} {
	    if {[set PourcentagePhylumTouche($P)] >= [set SeuilPhylumTouche($P)]} {
		append TexteBAE [string toupper $P]  
	    } else {
		append TexteBAE [string tolower $P]  
	    } 
	    lappend Resume "[set PhylumTouche($P)] [set PhylumTotal($P)]"
	}
	set SonBAE "$Nom $TexteBAE [join $Resume " "]"
	Espionne $SonBAE
	lappend LesBAEs $SonBAE
    }
    SauveLesLignes $LesBAEs dans $FichierPhylumsOrthologues
    return [PhylumsOrthologues $Nom]    
}

proc AlignonsLesParalogues {} {
    global RepertoireDuGenome
    global NotreOS
    global NotreOrga

    set FichierParalogues "$RepertoireDuGenome/fiches/paralogues.blastp"
    if { ! [file exists $FichierParalogues]} { LesParaloguesDuBlastP }
    Alignons Paralogues
}

proc LesParaloguesDuBlastPPourMs {{Source ""} {SeuilExpect ""}} {
    
    if {$SeuilExpect==""} { set SeuilExpect 0.001 }
    set MaxListe 999

    set FichierParalogues "[RepertoireDuGenome]/fiches/paraloguesMs"
    if {[FileExists $FichierParalogues]} {
	foreach Ligne [LesLignesDuFichier $FichierParalogues] {
	    scan $Ligne "%s" Nom
	    set DejaVu($Nom) 1
	}
    }

    if {$Source==""} { set Source "blastp" }

    if {$Source=="blastp"} {
	foreach Nom [ListeDesPABs] {
	    Espionne "je cherche les paralogues pour $Nom"
	    if {[info exists DejaVu($Nom)]} { continue }
	    set FichierBlast [GscopeFile $Nom "blastp"]
	    if {[FileAbsent $FichierBlast]} {continue}
	    set n [DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query \
		    lBanqueId lAccess lDE lProfil lPN]
	    if {$n==0} { continue }
	    set MesParalogues {}
	    foreach BanqueId $lBanqueId Access $lAccess {
		if {[regexp -nocase {\:} $BanqueId]} {
		    set NomLu [StringApres ":" dans $BanqueId]
		    if {$NomLu==$Nom} { continue }
		    if {[EstUnPAB $NomLu]} {
			lappend MesParalogues $NomLu
			continue
		    }
		}
	    }
	    if {$MesParalogues=={}} { continue }
	    set BonneLigne "$Nom [join $MesParalogues " "]"
	    Espionne $BonneLigne
	    AppendAuFichier $FichierParalogues $BonneLigne
	}
    }
    return $FichierParalogues
}

proc LesParaloguesDuBlastP {} {
    global RepertoireDuGenome
    global NotreOS
    global NotreOrga
    
    set FichierParalogues "$RepertoireDuGenome/fiches/paralogues.blastp"

    set LesNomParalogues {} 
    set LesNomAPNs {}

    foreach Nom [ListeDesPABs] {
	set SesParalogues {}
	set SesAPNs {}
	set FichierAPNs "$RepertoireDuGenome/apns/$Nom"
	if {[file exists $FichierAPNs]} {
	    foreach Ligne [LesLignesDuFichier $FichierAPNs] {
		scan $Ligne "%s %s %f" BanqueId Access PN
		if { $PN > 0.001 } { break }
		set Para [Narcisse $Access]
		if {$Para==$Nom} { continue }
		if { ! [regexp "[ExpressionReguliereDesPABs]" $Para]} { continue }
		lappend SesParalogues $Para
		lappend SesAPNs "$BanqueId $Access $PN"
	    }
	}
	lappend LesNomParalogues "$Nom [join $SesParalogues " "]"
	foreach APN $SesAPNs {
	    lappend LesNomAPNs "$Nom $APN"
	}
    }
    Espionne [SauveLesLignes $LesNomParalogues dans "$FichierParalogues"]
    Espionne [SauveLesLignes $LesNomAPNs dans "$FichierParalogues.apn"]

    return $FichierParalogues
}

proc AfficheLesOrthologuesFamiliersDuBlastP Nom {
    set LesOF [LesOrthologuesFamiliersDuBlastP $Nom]
    return [AfficheVariable [join $LesOF "\n"] "AvecRien" $Nom]
}

proc LesOrthologuesFamiliersDuBlastP {{Nom "CreateIt"} {Quoi "All"}} {
    global RepertoireDuGenome
    global NotreOS
    global NotreOrga

    set FichierOrthologuesFamiliers "$RepertoireDuGenome/fiches/orthologues.familiar"

    if {$Nom!="CreateIt"} {
	if { ! [file exists $FichierOrthologuesFamiliers]} { return "" }
	set DejaPasse 0
	set LesOrthos {}
	foreach Ligne [LesLignesDuFichier $FichierOrthologuesFamiliers] {
	    scan $Ligne "%s" NomLu
	    if {$NomLu!=$Nom && ! $DejaPasse } { continue }
	    if {$NomLu!=$Nom &&   $DejaPasse } { break }
	    scan $Ligne "%s %s %s %s %s %s" NomLu BanqueId Access Expect Genre Espece
	    switch -regexp $Quoi {
		"All"      { set Texte "$BanqueId $Access $Expect $Genre $Espece" }
		"BanqueId" { set Texte "$BanqueId"                                }
		"Access"   { set Texte           "$Access"                        }
		"Expect"   { set Texte                   "$Expect"                }
		"Orga"     { set Texte                           "$Genre $Espece" }
		default    { set Texte "$BanqueId $Access $Expect $Genre $Espece" }
	    }
	    set DejaPasse 1
	    lappend LesOrthos $Texte
	}
	return $LesOrthos
    }

    while {[file exists $FichierOrthologuesFamiliers]} {
	if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n \
		Do I cancel LesOrthologuesFamiliersDuBlastP ?"]} {
	    return $FichierOrthologuesFamiliers
	}
	if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n \
		Do I replace it ?"]} {
	    File delete -force $FichierOrthologuesFamiliers
	    break
	}
	if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n \
		Do I append to it ?"]} {
	    set LesAnciennes {}
	    foreach Ligne [LesLignesDuFichier $FichierOrthologuesFamiliers] {
		scan $Ligne "%s" NomLu
		set DejaVu($NomLu) 1
	    }
	    break
	}
    }

    set LesNomOrthologues {} 
    set LesNomAPNs {}
    foreach NomLu [ListeDesPABs] {
	if {[info exists DejaVu($NomLu)]} { continue }
	set SesAPNs {}
	set FichierAPNs "$RepertoireDuGenome/apns/$NomLu"
	if {[file exists $FichierAPNs]} {
	    foreach Ligne [LesLignesDuFichier $FichierAPNs] {
		set Genre ""
		set Espece ""
		set Organisme "" 
		scan $Ligne "%s %s %f %s %s" BanqueId Access PN Genre Espece
		if { $PN > 0.001 } { break }
		if {$Espece!=""} { set Organisme "$Genre $Espece" }
		if {$Organisme==""} {
		    continue
		    set Organisme [OrgaDuAccess $Access Complet $BanqueId]
		}
		if {$Organisme==""} { continue }
		if { ! [FamiliarOrganism $Organisme] && $Organisme!=$NotreOS} { continue }
		lappend SesAPNs "$NomLu $Ligne"
	    }
	}
	foreach APN $SesAPNs {
	    AppendAuFichier $FichierOrthologuesFamiliers [join $SesAPNs "\n"]
	}
    }
    return $FichierOrthologuesFamiliers
}

proc LesParaloguesDuMSF {} {
    global RepertoireDuGenome
    global NotreOS
    global NotreOrga

    set FichierParalogues  "$RepertoireDuGenome/fiches/paralogues.msf"
    set FichierDistanceMSF "$RepertoireDuGenome/fiches/distancesphylo.$NotreOrga"

    while { ! [file exists $FichierDistanceMSF]} {
	if { ! [OuiOuNon "$FichierDistanceMSF\n doesn't exist. Do I calculate it ? "]} {
	    return ""
	} 
	set FichierDistanceMSF [CreeDistancesPhyloAvecLesMSFs $NotreOrga ".$NotreOrga"]
    }

    foreach Ligne [LesLignesDuFichier $FichierDistanceMSF] {
	scan $Ligne "%s" Nom
	set SesParalogues {}
	set SesDistances  {}
	set Premier 1
	foreach {Orga Dist Access} [lrange [split $Ligne " "] 1 end] {
	    if {$Orga!=$NotreOrga} { continue }
	    if {$Premier} { set Premier 0 }
	    set Para [Narcisse $Access]
	    if {$Para==$Nom} { continue }
	    lappend SesParalogues $Para
	    lappend SesDistances  $Dist
	}
	lappend LesNomParalogues "$Nom [join $SesParalogues " "]"
	lappend LesNomDistances  "$Nom [join $SesDistances " "]"
    }
    Espionne [SauveLesLignes $LesNomParalogues dans "$FichierParalogues"]
    Espionne [SauveLesLignes $LesNomDistances  dans "$FichierParalogues.dist"]
}

proc FromRef {Ref Champ} {
    if { ! [regexp -nocase {[a-z_0-9]} $Ref]} { return "" }
    set Liste {}
    foreach Ligne [split $Ref "\n"] {
	if {[regexp "^$Champ" $Ligne]} {
	    regsub "$Champ   " $Ligne "" Texte
	    lappend Liste [string trim $Texte]
	}
    }
    return [join $Liste " "]
}

proc InformeClassePourTous {} {
    foreach Nom [ListeDesPABs] {
	set TaxOS [OrganismeDuPAB $Nom] 
	if {$TaxOS==""} { continue }
	scan $TaxOS "%d" TaxId
	set Classe [TaxClass $TaxId "" "" Name]
	Espionne "$Nom Taxonomy: $Classe"
	InformeSansDemander $Nom "Taxonomy: $Classe"
    }
}

proc InformePourTous {{Clef ""} {Commande ""}} {
    foreach Nom [ListeDesPABs] {
		set Valeur ""
		if {$Commande!=""} { set Valeur [eval $Commande $Nom] }
		#rR if {$Valeur==""} { continue }
		Espionne "$Nom $Clef: $Valeur"
		if {$Clef!=""} {
			InformeSansDemander $Nom "$Clef: $Valeur"
		} else {
			InformeSansDemander $Nom ""
		}
    }
}

proc LesChampsInteressantsDeNarcisse {} {
    return {ID AC DE GN}
}

proc InformeParNarcissePourTous {} {
    foreach Nom [ListeDesPABs] {
	InformeParNarcisse $Nom
    }
}

proc InformeParNarcisse Nom {

    set Nar [Narcisse $Nom]
    if {$Nar==""} { Espionne "$Nom ++++" ;return "" }
    set Ref [RefOfAC $Nar]
    if {$Ref==""} { Espionne "$Nom ----" ;return "" }
    Espionne "$Nom $Nar"
    foreach Champ [LesChampsInteressantsDeNarcisse] {
	set Texte "${Champ}_Narcisse: [FromRef $Ref $Champ]"
	lappend LesTextes $Texte
    }
    set Textes [join $LesTextes "\n"]
    return [InformeSansDemander $Nom $Textes]
}

proc InformeParClonagePourTous {{GenomeOrigine ""} {Champ ""}} {
    foreach Nom [ListeDesPABs] {
	if {[InformeParClonage $Nom $GenomeOrigine $Champ]=="Cancel"} { return "Cancel" } 
    }
}

proc InformeParClonage {Nom {GenomeOrigine ""} {Champ ""}} {
    global RepertoireDuGenome
    global GenomeACloner PrefixeDuGenomeACloner

    if {$GenomeOrigine!=""} {
	set GenomeACloner $GenomeOrigine
	if { ! [file exists $GenomeACloner]} {
	    set GenomeACloner "$RepertoireDuGenome/../[file tail $GenomeACloner]"
	    set PrefixeDuGenomeACloner [PrefixeDuGenome $GenomeACloner]
	}
	if { ! [file exists $GenomeACloner]} {
	    if { [OuiOuNon "$GenomeOrigine\n and \n$GenomeACloner\n don't exist.\n Do I cancel ?"]} {
		return "Cancel"
	    }
	    unset GenomeACloner
	}
    }

    while { ! [info exists GenomeACloner]} {
	FaireLire "Please select the genome from which the info have to be taken."
	set GenomeACloner [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
	if {$GenomeACloner==""} {
	    if {[OuiOuNon "Do I cancel ?"]} { return "Cancel" }
	    continue
	}
	set PrefixeDuGenomeACloner [PrefixeDuGenome $GenomeACloner]
	break
    }

    if {[file tail $GenomeACloner]==[file tail $RepertoireDuGenome]} {
	FaireLire "You want to clone myself ... I cancel."
	return "Cancel"
    }

    regsub "^[PreFixe]" $Nom $PrefixeDuGenomeACloner PAB
    set FichierInfo "$GenomeACloner/infos/$PAB"
    if { ! [file exists $FichierInfo]} { return "" }
    set OnAttendLeBon 1
    set LesTextes {}
    foreach Ligne [LesLignesDuFichier $FichierInfo] {
	if {$OnAttendLeBon && $Ligne=="Nom: $PAB"} {
	    set OnAttendLeBon 0
	    continue
	}
	if {$OnAttendLeBon} {
	    if {[OuiOuNon "$PAB is wrong, Do You want to see the info file ?"]} {
		AfficheFichier $FichierInfo "SansFetch" 
	    }
	    if {[OuiOuNon "$PAB is wrong, Do I cancel ?"]} { return "Cancel"}
	    if {[OuiOuNon "$PAB is wrong, Do I skipp it ?"]} { return ""}
	    if { ! [OuiOuNon "$PAB is wrong, Do I accept it ?"]} { exit }
	    set OnAttendLeBon 0
	}
	if {$PrefixeDuGenomeACloner!=[PreFixe]} {
	    while {[regexp "$PrefixeDuGenomeACloner\[0-9\]+" $Ligne Match]} {
		regsub $PrefixeDuGenomeACloner $Match [PreFixe] NouveauMatch
		regsub -all $Match $Ligne $NouveauMatch Ligne
	    }
	}
	if {$Champ!="" && ! [regexp "^$Champ: " $Ligne]} { continue }
	lappend LesTextes $Ligne
    }
    if {$LesTextes=={}} { return "" }
    set Textes [join $LesTextes "\n"]
    Espionne "Clonage de $PAB vers $Nom $Textes"
    return [InformeSansDemander $Nom $Textes]
}

proc RefOfAC AC {
   return [QuestionDeScience QuidSeq "QuidRefOfAC $AC"]
}

proc CouleursDuRougeAuBleu n {
    if {$n==1} { return {      red                                          } }
    if {$n==2} { return {      red                               blue       } }
    if {$n==3} { return {      red               green           blue       } }
    if {$n==4} { return {      red orange        green           blue       } }
    if {$n==5} { return {      red orange        green lightblue blue       } }
    if {$n==6} { return {      red orange yellow green lightblue blue       } }
    if {$n==7} { return {brown red orange yellow green lightblue blue       } }
    if {$n==8} { return {brown red orange yellow green lightblue blue purple} }
    if {$n<=0} { return {} }
    return [concat [CouleursDuRougeAuBleu [incr n -1]] [list black]]
}

proc CouleursDuBleuAuRouge n {
    return [RetourneLaListe [CouleursDuRougeAuBleu $n]]
}

proc LesSeuilsMDScore {{QueVeutOn "SeuilMerci"}} {
    global LesSeuilsMDScore LesSeuilsMDScoreSign LesSeuilsMDScoreCoul

    if { ! [info exists LesSeuilsMDScore]} {
	set LesSeuilsMDScore     {       -999.0     0.0              0.5      0.7      0.9 }
	set LesSeuilsMDScoreSign {"No value" "Problem" "Twilight zone" "Good"   "Sure"}
	set LesSeuilsMDScoreCoul {"grey"     "red"     "orange"        "yellow" "green"}
    }
    if {$QueVeutOn=="SeuilMerci"}         { return $LesSeuilsMDScore }
    if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsMDScoreSign }
    if {$QueVeutOn=="CouleurMerci"}       { return $LesSeuilsMDScoreCoul }
}

proc TSOH {} {
    set OHLaListe [CompteDesOrganismesAyantMemeOperon "LaListeMerci"] 
    Espionne [lsort -integer $OHLaListe]

    Espionne [MoyenneEcartMinMaxCumulLong $OHLaListe]
}

proc LesSeuilsOperonsHomologues {{QueVeutOn ""}} {
    global LesSeuilsOperonsHomologues LesSeuilsOperonsHomologuesSign

    if { ! [info exists LesSeuilsOperonsHomologues]} {
#	set OHLaListe [CompteDesOrganismesAyantMemeOperon "LaListeMerci"]
#	scan [MoyenneEcartMinMaxCumulLong $OHLaListe] "%f %f %d %d" Mo Ec Mi Ma
	lappend LesSeuilsOH [format "%4.1f"  0.1]
	lappend LesSeuilsOH [format "%4.1f"  1.1]
	lappend LesSeuilsOH [format "%4.1f"  2.1]
	lappend LesSeuilsOH [format "%4.1f" 10.1]
	lappend LesSeuilsOH [format "%4.1f" 20.1]
	lappend LesSeuilsOHSign "ClusterMaintenance 0 == n"
	lappend LesSeuilsOHSign "ClusterMaintenance 1 == n"
	lappend LesSeuilsOHSign "ClusterMaintenance 2 <= n < 10"
	lappend LesSeuilsOHSign "ClusterMaintenance 10 < n <= 20"
	lappend LesSeuilsOHSign "ClusterMaintenance 20 < n"
    }
    if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsOHSign }
    return $LesSeuilsOH
}

proc LesSeuilsGC {{QueVeutOn ""}} {
    global LesSeuilsGC LesSeuilsGCSign

    if { ! [info exists LesSeuilsGC]} {
	set GCLaListe [CompositionEn GC "LaListeMerci"]
	scan [MoyenneEcartMinMaxCumulLong $GCLaListe] "%f %f %d %d" Mo Ec Mi Ma
	lappend LesSeuilsGC [format "%4.1f" [expr $Mo-2*$Ec]]
	lappend LesSeuilsGC [format "%4.1f" [expr $Mo-1*$Ec]]
	lappend LesSeuilsGC [format "%4.1f" [expr $Mo+1*$Ec]]
	lappend LesSeuilsGC [format "%4.1f" [expr $Mo+2*$Ec]]
	set i -1
	lappend LesSeuilsGCSign "GC skew verylow  (       %GC < [lindex $LesSeuilsGC [incr i]])"
	lappend LesSeuilsGCSign "GC skew low      ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])"
	lappend LesSeuilsGCSign "GC skew normal   ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])"
	lappend LesSeuilsGCSign "GC skew high     ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])"
	lappend LesSeuilsGCSign "GC skew veryhigh ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])"
    }
    if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsGCSign }
    return $LesSeuilsGC
}

proc LesSeuilsAC {{QueVeutOn ""}} {
    global LesSeuilsAC LesSeuilsACCoul LesSeuilsACSign

    if { ! [info exists LesSeuilsAC]} {
	set ACLaListe [AnchorsCount "LaListeMerci"]
	scan [MoyenneEcartMinMaxCumulLong $ACLaListe] "%f %f %d %d" Mo Ec Mi Ma
	lappend LesSeuilsAC [format "%4.1f" [Maxi 1.0 [expr $Mo-2*$Ec]]]
	lappend LesSeuilsAC [format "%4.1f" [Maxi 2.0 [expr $Mo-1*$Ec]]]
	lappend LesSeuilsAC [format "%4.1f" [expr $Mo+1*$Ec]]
	lappend LesSeuilsAC [format "%4.1f" [expr $Mo+2*$Ec]]
	lappend LesSeuilsACCoul "red"
	lappend LesSeuilsACCoul "orange"
	lappend LesSeuilsACCoul "yellow"
	lappend LesSeuilsACCoul "green"
	set i -1
	lappend LesSeuilsACSign "AC verylow  (       %AC < [lindex $LesSeuilsAC [incr i]])"
	lappend LesSeuilsACSign "AC low      ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])"
	lappend LesSeuilsACSign "AC normal   ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])"
	lappend LesSeuilsACSign "AC high     ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])"
	lappend LesSeuilsACSign "AC veryhigh ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])"
    }
    if {$QueVeutOn=="CouleurMerci"} { return $LesSeuilsACCoul }
    if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsACSign }
    return $LesSeuilsAC
}

proc LesSeuilsCAI {{QueVeutOn ""}} {
    global LesSeuilsCAI LesSeuilsCAISign

    if { ! [info exists LesSeuilsCAI]} {
	set CAILaListe [CAI "LaListeMerci"]
	scan [MoyenneEcartMinMaxCumulLong $CAILaListe] "%f %f %d %d" Mo Ec Mi Ma
	lappend LesSeuilsCAI [format "%4.1f" [expr $Mo-2*$Ec]]
	lappend LesSeuilsCAI [format "%4.1f" [expr $Mo-1*$Ec]]
	lappend LesSeuilsCAI [format "%4.1f" [expr $Mo+1*$Ec]]
	lappend LesSeuilsCAI [format "%4.1f" [expr $Mo+2*$Ec]]
	set i -1
	lappend LesSeuilsCAISign "CAI verylow  (        CAI < [lindex $LesSeuilsCAI [incr i]])"
	lappend LesSeuilsCAISign "CAI low      ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])"
	lappend LesSeuilsCAISign "CAI normal   ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])"
	lappend LesSeuilsCAISign "CAI high     ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])"
	lappend LesSeuilsCAISign "CAI veryhigh ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])"
    }
    if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsCAISign }
    return $LesSeuilsCAI
}

proc QuelInterval {Valeur LesBornes LesIntervals} { 
    foreach Borne $LesBornes Interval $LesIntervals {
	if {$Valeur < $Borne} { return $Interval }
    }
    return [lindex $LesIntervals end]
}

proc GCLevel Nom {
    set GC [CompositionEn GC $Nom]
    return [QuelInterval $GC [LesSeuilsGC] [LesSeuilsGC "SignificationMerci"]]
}

proc GCContent Nom {
    return [CompositionEn GC $Nom]
}

proc TasTamis {{Tam ""} {Fichier ""}} {
    global TasTamis

    Wup "Create a file Fichier (or returns a list) with 'Nom Value' foreach Nom verifying Tam" 

    if {[info exists TasTamis]} { unset TasTamis }

    CreeLeTasTamis $Tam
    set Liste {}
    foreach Nom [array names TasTamis] {
	lappend Liste "$Nom [set TasTamis($Nom)]"
    }
    if {$Fichier==""} {
	return $Liste
    } else {	
	return [SauveLesLignes $Liste dans $Fichier]
    }
}

proc SauveLeTamis {{Tam ""} {Fichier ""}} {
    if {$Tam==""} {
	set Tam [ChoisisUnTamis "ChampNom" "AvecNewTamis"]
    }
    if {$Fichier==""} {
	set Fichier [FichierPourSaveAs]
    }
    if {$Fichier==""} { return "" }
    return [SauveLesLignes [Tamis $Tam] dans $Fichier]
}

proc CreeLeTasTamis {{Tam ""}} {
    global TasTamis

    Wup "Creates the array TasTamis(Nom) for a Tamis Tam which can be choosen"

    if {$Tam==""} {
	set Tam [ChoisisUnTamis "ChampNom" "AvecNewTamis"]
    }
    if {[info exists TasTamis]} { unset TasTamis }
    foreach Nom [Tamis $Tam] {
	set TasTamis($Nom) 1
    }
    set TasTamis(FromTamis) $Tam
    return $Tam
}

proc ScanCOV {COV aCritere aOperateur aValeur} {
    upvar $aCritere Critere
    upvar $aOperateur Operateur 
    upvar $aValeur Valeur
    scan $COV "%s %s" Critere Operateur
    regsub "$Critere +$Operateur +" $COV "" Valeur
}

proc NoCo {Action {No ""} {Co ""}} {
    global RepertoireDuGenome
    global NoCo
    global NoCoEstCharge

    Wup "NoCo 'NomCommande' manages the Criteria file and array NoCo"

    if { ! [info exists FichierNoCo]} { set FichierNoCo "$RepertoireDuGenome/fiches/nomcommande-criteres" }

    if {$Action=="Recharger"} {
	if {[info exists NoCoEstCharge]} {unset NoCoEstCharge}
    }

    if { ! [info exists NoCoEstCharge]} {
	while { ! [file exists $FichierNoCo]} {
	    if {[OuiOuNon "Do I create a Criteria file ?"]} {
		set LesNoCos {}
		lappend LesNoCos "NewCriteria X X X"
		lappend LesNoCos "UnPAB Echo == ?"
		lappend LesNoCos "AAStartM AAStart == M"
		lappend LesNoCos "AAStartV AAStart == V"
		lappend LesNoCos "AAStartL AAStart == L"
		SauveLesLignes $LesNoCos dans $FichierNoCo
	    } else {
		set NoCoEstCharge 1
		break
	    }
	}
	if { ! [info exists NoCoEstCharge]} {
	    foreach Ligne [LesLignesDuFichier $FichierNoCo] {
		scan $Ligne "%s" NoLu
		regsub "$NoLu +" $Ligne "" CoLu
		set NoCo($NoLu) $CoLu
	    }
	}
	set NoCoEstCharge 1
    }

    switch $Action {
	"LaListeMerci" { return [lsort [array names NoCo]] }
	"ReCharger"    { return [lsort [array names NoCo]] }
	"ReSauver" {
	    set LesNoCos {}
	    foreach No [lsort [array names NoCo]] {
		lappend LesNoCos "$No [set NoCo($No)]"
	    }
	    SauveLesLignes $LesNoCos dans $FichierNoCo
	    return [NoCo "ReCharger"]
	}
	"MieuxNommer" {
	    if {[info exists NoCo($No)] && [set NoCo($No)]==$Co} { return $No }
	    FaireLire "Please give a name for the criteria\n$Co"
	    set NoLu [Entre]
	    while {[info exists NoCo($NoLu)] && [set NoCo($NoLu)]!=$Co} {
		if {[OuiOuNon "  The Old criteria\n\
			$NoLu [set NoCo($NoLu)]\n  will be replaced by\n$NoLu $Co\n  Do You accept ?"]} {
		    break
		}
		set NoLu [Entre]
	    }
	    Espionne "$NoLu $Co"
	    set NoCo($NoLu) $Co
	    NoCo "ReSauver"
	    return $NoLu
	}
	"Remplacer|Creer" {
	    set NoCo($No) $Co
	    return [NoCo "ReSauver"]
	}
	"Supprimer" {
	    if {[info exists NoCo($No)]} {unset NoCo($No)}
	    return [NoCo "ReSauver"]
	}
	"Titre" {
	    if {[info exists NoCo($No)]} {
		return $No
	    } else {
		return ""
	    }
	}
	"Commande" {
	    if {[info exists NoCo($No)]} {
		return [set NoCo($No)]
	    } else {
		return ""
	    }
	}
	"Tout" {
	    if {[info exists NoCo($No)]} {
		return "$No [set NoCo($No)]"
	    } else {
		return ""
	    }
	}
	default { FaireLire "Illegal Action $Action" ; return "" } 
    }
}

proc ChoixDansLaListeFait Texte {
    global ChoixDansLaListe

    Wup "Tests the selection for NormalSelection, Cancel or NewCommand" 

    if {$Texte==""} { return }
    if {$Texte=="PasDeChoixDansLaListe"} { set ChoixDansLaListe "" ; return }
    if {$Texte=="NouveauChoixDansLaListe"} {
	set ChoixDansLaListe [Entre]
	return 
    }
    set ChoixDansLaListe $Texte
    return 
}

proc ChoixDansLaListe {Liste {SansRetour ""}} {
    global ChoixDansLaListe

    Wup "Displays a list and ask for a selection"

    if {$SansRetour=="SansRetour"} {
	set Titre "For display only ..."
    } else {
	set Titre "Select a line and Accept"
    }

    set Fenetre [ShowText [join $Liste "\n"] "SansFetchAvecRien" $Titre]
    if {$SansRetour=="SansRetour"} { return }
    set   Bouton [BoutonneLaFenetre $Fenetre "Accept/Cancel/New" ""]
         $Bouton configure -background "green"
    bind $Bouton  <1> "ChoixDansLaListeFait \[selection get\] "
    bind $Bouton  <2> "ChoixDansLaListeFait PasDeChoixDansLaListe"
    bind $Bouton  <3> "ChoixDansLaListeFait NouveauChoixDansLaListe"
    set   Bouton [BoutonneLaFenetre $Fenetre "Show Criteria" ""]
         $Bouton configure -background "yellow"
    bind $Bouton  <1> "ChoisisUneGrille SansRetour"

    tkwait variable ChoixDansLaListe
    set LigneChoisie $ChoixDansLaListe
    unset ChoixDansLaListe
    destroy $Fenetre
    return $LigneChoisie
}

proc NommeEtStockeLeTamis Commande {

    Wup "Gives a name to the Tamis"

    if {[LeTamis NeConnaitPasEncore $Commande]} {
	while {[OuiOuNon "$Commande\nwill be a new Tamis ?"]} {
	    FaireLire "Please give a name"
	    set NewTamis [Entre "Tamis_"]
	    if {$NewTamis==""} { continue }  
	    LeTamis $NewTamis $Commande
	    break
	}
    }
}

proc ChoisisUneGrille {{ChampChoisi ""}} {

    Wup "Displays the known Criterias and asks for a selection"

    set LesGrillesExistantes [NoCo "LaListeMerci"]
    if { $LesGrillesExistantes=={} } { return "" }
    foreach Grille $LesGrillesExistantes {
	set COV [NoCo "Commande" $Grille]
	lappend LesBellesGrilles [format "%-20s %s" $Grille $COV]
    }
    if {$ChampChoisi=="SansRetour"} {
	set ChampsNomEtCommande [ChoixDansLaListe $LesBellesGrilles "SansRetour"]
	return
    } else {
	set ChampsNomEtCommande [ChoixDansLaListe $LesBellesGrilles]
    }
    if {$ChampsNomEtCommande==""} { return "" }
    scan $ChampsNomEtCommande "%s" Grille
    return $Grille
}

proc ChoisisUnTamis {{ChampChoisi ""} {AvecNewTamis ""}} {

    Wup "Displays the known Tamis and asks for a selection"

    set LesTamisExistants [LeTamis "LaListeMerci"]
    if { $LesTamisExistants=="TamisInconnu" } {
	LeTamis AllPABs  "ListeDesPABs"
	LeTamis AllTRNAs "ListeDesTRNAs"
	LeTamis AllARNs  "ListeDesARNs"
	set LesTamisExistants [LeTamis "LaListeMerci"]
    }
    set LesBeauxTamis {}
    if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisWhere X Where X] }
    if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisAnd X And X] }
    if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisOr X Or X] }
    if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisButNot X ButNot X] }
    foreach Tam $LesTamisExistants {
	lappend LesBeauxTamis [format "%-20s %s" $Tam [LeTamis $Tam]]
    }
    set ChampsNomEtCommande [ChoixDansLaListe $LesBeauxTamis]
    if {$ChampsNomEtCommande==""} { return "" }
    scan $ChampsNomEtCommande "%s" Tam
    if {$ChampChoisi=="ChampNom"} { return $Tam } 
    if {$ChampChoisi=="ChampCommande"} { return [LeTamis $Tam] } 
    return "$Tam [LeTamis $Tam]"
}

proc LeTamis {Tam {Commande ""}} {
    global RepertoireDuGenome
    global LeTamis
    global LeTamisDeLaCommande

    Wup "Manages the file and array containing the Tamis"

    set FichierDesTamis "$RepertoireDuGenome/fiches/nomcommande-tamis"

    if {$Tam=="RelireEtReecrireLeFichierDesTamis"} {
	if {[info exists LeTamis]} {unset LeTamis}
	set ReecrireLeFichierDesTamis 1
    } else {
	set ReecrireLeFichierDesTamis 0
    }

    if {$Tam=="NeConnaitPasEncore" || $Tam=="LeNomDuTamisAssocieA"} {
	if { ! [info exists LeTamis(EstCharge)]} { LeTamis Turlututu } 
	if {[info exists LeTamisDeLaCommande($Commande)]} {
	    return 0
	} else {
	    if {$Tam=="NeConnaitPasEncore"} { return 1 }
	    if {$Tam=="LeNomDuTamisAssocieA"} { return [set LeTamisDeLaCommande($Commande)] }
	}
    }

    if {$Commande!=""} {
	set CommandeExistante [LeTamis $Tam]
	if {$CommandeExistante=="TamisInconnu"} {
	    AppendAuFichier $FichierDesTamis "$Tam $Commande"
	    if {[info exists LeTamis]} { unset LeTamis }
	    return [LeTamis $Tam]
	}
	if {$CommandeExistante==$Commande} { return $Commande }
	if {[OuiOuNon "  The new\n$Tam $Commande\n  wants to replace the old\n$Tam $CommandeExistante\n  Do you want to replace it ?"]} {
	    AppendAuFichier $FichierDesTamis "$Tam $Commande"
	    if {[info exists LeTamis]} { unset LeTamis }
	    LeTamis "RelireEtReecrireLeFichierDesTamis"
	    return [LeTamis $Tam]
	}
	return ""
    }

    if {[info exists LeTamis($Tam)]} { return [set LeTamis($Tam)]}
    if {[info exists LeTamis(EstCharge)]} { return "TamisInconnu"}

    if {[file exists $FichierDesTamis]} {
	set LesLignesTamis [LesLignesDuFichier $FichierDesTamis]
    } else {
	set LesLignesTamis {}
    }
    if {[info exists LeTamis]} { unset LeTamis }
    foreach Ligne $LesLignesTamis {
	scan $Ligne "%s" TamisLu
	regsub "$TamisLu " $Ligne "" CommandeLue
	set LeTamis($TamisLu) $CommandeLue
	set LeTamisDeLaCommande($CommandeLue) $TamisLu
    }
    set LesLignesTamis {}
    set LaListe {}
    foreach TamExistant [lsort [array names LeTamis]] {
	lappend LeTamis(LaListeMerci) $TamExistant
	lappend LesLignesTamis "$TamExistant [set LeTamis($TamExistant)]"
    }
    if {$ReecrireLeFichierDesTamis} { SauveLesLignes $LesLignesTamis dans $FichierDesTamis }

    set LeTamis(EstCharge) "TamisCharge"
    if {[info exists LeTamis($Tam)]} { return [set LeTamis($Tam)]}
    if {[info exists LeTamis(EstCharge)]} { return "TamisInconnu"}
}

proc AlwaysTrue Nom {
    return 1
}

proc Echo Nom {
    return $Nom
}

#a b c .
#d e . .
#g h i k

#a d g
#b e h
#c . i
#. . k

proc TestListTranspose {} {
    set LL {{a b c} {d e} {g h i k}}
    EspionneL $LL
    EspionneL [ListTranspose $LL]
    return [ListTranspose $LL]
}

proc ListTranspose LL {
    #rR LL peut avoir des lignes de longueurs différentes 
    #rR On est obligé de passer par un tableau à 2 dimensions
    set MaxICol -1
    set iLig 0
    foreach Ligne $LL {
	set iCol 0
	set LesCol {}
	foreach e $Ligne {
	    lappend LesCol $iCol
	    lappend T($iLig,$iCol) $e
	    incr iCol
	}
	set MaxICol [expr max($MaxICol,[llength $LesCol]-1)]
	incr iLig
    }
    set MaxILig [expr $iLig-1]

    set N {}
    set Vide "NA"
    foreach iCol [NombresEntre 0 $MaxICol] {
	set Colonne {}
	foreach iLig [NombresEntre 0 $MaxILig] {
	    if {[info exists T($iLig,$iCol)]} {
		lappend Colonne $T($iLig,$iCol)
	    } else {
		lappend Colonne $Vide
	    }
	}
#	Espionne $Colonne
	lappend N $Colonne
    }
    return $N
} 

proc ListsUnion {LesA LesB} {
    set LesAB [ListeSansDoublon [concat $LesA $LesB]]
    return $LesAB  
}

proc ListsIntersection {LesA LesB {NoCase ""}} {

    #rR si NoCase on garde quand meme les A avec leur casse 
    set NoCase [string equal -nocase $NoCase "NoCase"]

    foreach B $LesB {
	if {$NoCase} { set B [string tolower $B] }
	set Existe($B) 1
    }
    set InterAB {}
    foreach A $LesA {
	set a $A
	if {$NoCase} { set a [string tolower $A] }
	if {[info exists Existe($a)]} {
	    lappend InterAB $A
	}
    }
    return $InterAB  
}

proc ListsComplement {LesA LesB} {
    Wup "A butnot B"
    foreach B $LesB {
	set Existe($B) 1
    }
    set ComplementAB {}
    foreach A $LesA {
	if {! [info exists Existe($A)]} {
	    lappend ComplementAB $A
	}
    }
    return $ComplementAB  
}

proc SelectionneCeCritere Texte {
    global CritereSelectionne

    Wup "Give a value to the waiting variable CritereSelectionne"

    if {$Texte=="CritereNonVoulu"} {
	set Critere ""
    } else {
	scan $Texte "%s" Critere
    }
    set CritereSelectionne $Critere
}

proc ChoisisLeCritere {} {
    global CritereSelectionne

    Wup "Asks for a Criteria (the name of a Proc)"

    set Fenetre [AfficheLesProcs "ArgsContain:^Nom"]
    set   Bouton [BoutonneLaFenetre $Fenetre "Select\nCancel" "SelectionneCeCritere \[selection get\]"]
         $Bouton configure -background "orange"
    bind $Bouton  <Shift-1> "SelectionneCeCritere CritereNonVoulu"

    tkwait variable CritereSelectionne
    set Critere $CritereSelectionne
    unset CritereSelectionne
    catch { destroy $Fenetre }
    return $Critere
}

proc TesteTamis {} {
    set Commande [ChoisisUnTamis "ChampCommande"]
    if {$Commande==""} { exit }
    Espionne [eval $Commande]
    exit
}

proc Tamis {{TamisOuListe ListeDesPABs} {Action ForAll} \
	{TamisOuListe2OuGrilleOuCritere X} {Operateur ""} {Valeur ""}} {

    if {[regexp "^NewTamis" $TamisOuListe]} {
	regsub "NewTamis" $TamisOuListe "" Action
	set TamisOuListe "X"
	set TamisOuListe2OuGrilleOuCritere "X"
    }
    if {$TamisOuListe=="X"} {
	set NomTamisEntrant [ChoisisUnTamis "ChampNom"]
	if {$NomTamisEntrant==""} { return {} }
	set ComTamisEntrant [LeTamis $NomTamisEntrant] 
    } elseif {[LeTamis $TamisOuListe]!="TamisInconnu"} {
	set NomTamisEntrant $TamisOuListe
	set ComTamisEntrant [LeTamis $NomTamisEntrant] 
    } else {
	set NomTamisEntrant $TamisOuListe
	set ComTamisEntrant $TamisOuListe
    }

    if {[regexp -nocase "ForAll" $Action]} {
	if {$ComTamisEntrant=="TamisInconnu"} { return {} }
	return [eval $ComTamisEntrant]
    }

    if {[regexp -nocase "And|Or|ButNot" $Action]} {
	set TamisOuListe2 $TamisOuListe2OuGrilleOuCritere
	if {$TamisOuListe2=="X"} {
	    set NomTamisEntrant2 [ChoisisUnTamis "ChampNom"]
	    if {$NomTamisEntrant2==""} { return {} }
	    set ComTamisEntrant2 [LeTamis $NomTamisEntrant2] 
	} elseif {[LeTamis $TamisOuListe2]!="TamisInconnu"} {
	    set NomTamisEntrant2 $TamisOuListe2
	    set ComTamisEntrant2 [LeTamis $NomTamisEntrant2] 
	} else {
	    set NomTamisEntrant2 $TamisOuListe2
	    set ComTamisEntrant2 $TamisOuListe2
	}
	set Commande "Tamis $NomTamisEntrant $Action $NomTamisEntrant2"
	NommeEtStockeLeTamis $Commande
	if {$ComTamisEntrant=="TamisInconnu"} {	    
	    set ListeDeNoms1 {}
	} else {
	    set ListeDeNoms1 [eval $ComTamisEntrant]
	}
	if {$ComTamisEntrant2=="TamisInconnu"} {	    
	    set ListeDeNoms2 {}
	} else {
	    set ListeDeNoms2 [eval $ComTamisEntrant2]
	}
	switch [string toupper $Action] {
	    "AND"    { return [ListsIntersection $ListeDeNoms1 $ListeDeNoms2] }
	    "OR"     { return [ListsUnion $ListeDeNoms1 $ListeDeNoms2] }
	    "BUTNOT" { return [ListsComplement $ListeDeNoms1 $ListeDeNoms2] }
	}
	FaireLire "Y a un probleme dans Tamis"
	return {}
    }

    if {[regexp -nocase "Where" $Action]} {
	set NoMayBe "NoMayBe"
	set GrilleOuCritere $TamisOuListe2OuGrilleOuCritere
	if {$Operateur==""} {
	    set Grille $GrilleOuCritere
	    if {$Grille=="X"} {
		set Grille [ChoisisUneGrille]
	    }
	    set NoMayBe $Grille
	    set COV [NoCo "Commande" $Grille]
	    ScanCOV $COV Critere Operateur Valeur
	} else {
	    set Critere $GrilleOuCritere
	}
	if {$Critere=="X"} {
	    set Critere [ChoisisLeCritere]
	    if {$Critere==""} {
		set Critere "AlwaysTrue"
		set Operateur "=="
		set Valeur "1"
	    }
	}
	if {$Operateur=="X"} {
	    set Operateur [ChoixDansLaListe {"<"  "<=" "==" ">=" ">" "!=" "Contains" "NotContains"} ]
	}
	if {$Valeur=="X"} {
	    set Valeur [Entre]
	}
	if {$Valeur=="?"} {
	    set QuestionnerToujours 1
	    set Valeur [Entre]
	} else {
	    set QuestionnerToujours 0
	}
	
	if {$QuestionnerToujours} {
	    set COV "$Critere $Operateur ?"
	} else {
	    set COV "$Critere $Operateur $Valeur"
	}
	set Grille [NoCo "MieuxNommer" $NoMayBe $COV]
	
	set Commande "Tamis $NomTamisEntrant $Action $Grille"
	NommeEtStockeLeTamis $Commande
	
	set LesBons {}
	set CasFavorables {}
	switch $Operateur {
	    "<"  { set CasFavorable {"-1"}     }
	    "<=" { set CasFavorable {"-1" "0"} }
	    "==" { set CasFavorable {"0"}      }
	    ">=" { set CasFavorable {"0" "1"}  }
	    ">"  { set CasFavorable {"1"}      }
	    "!=" { set CasFavorable {"-1" "1"} }
	    default { set CasFavorable "1" }
	}
	
	regsub {\?$} $Valeur "" Valeur

	if {$ComTamisEntrant=="TamisInconnu"} { return {} }
	set ListeDeNoms [eval $ComTamisEntrant]
	set AutresArgs ""
	set SesArgs [info args $Critere]
	set nArgs [llength $SesArgs]
	if {$nArgs>1} { 
	    FaireLire "$Critere \{$SesArgs\} need [incr nArgs -1] additionnal arguments. Please give me them."
	    set AutresArgs [Entre]
	}

	foreach Nom $ListeDeNoms {
	    if {$AutresArgs==""} {
		set ValeurCalculee [eval $Critere $Nom]
	    } else {
		set ValeurCalculee [eval $Critere $Nom $AutresArgs]
	    }
	    if {$Operateur=="Contains"} {
		set T [regexp -nocase "$Valeur" "$ValeurCalculee"]
	    } elseif {$Operateur=="NotContains"} {
		set T [expr ! [regexp -nocase "$Valeur" "$ValeurCalculee"]]
	    } else {
		if { ! [catch {if {[expr $ValeurCalculee $Operateur $Valeur]} { lappend LesBons $Nom }}]} { continue }
		set T [string compare $ValeurCalculee $Valeur]
	    }
	    foreach Cas $CasFavorable {
		if {$T==$Cas} {
		    lappend LesBons $Nom
		    break
		}
	    }
	}
	return $LesBons
    }
    if {[regexp -nocase "Keep" $Action]} {
	set NoMayBe "NoMayBe"
	set Critere $TamisOuListe2OuGrilleOuCritere
	if {$Critere=="X"} {
	    set Critere [ChoisisLeCritere]
	    if {$Critere==""} {
		set Critere "AlwaysTrue"
	    }
	}
	set COV [NoCo "Commande" $Critere]
	if {$COV!=""} {
	    set NoNomme $Critere
	    set Critere $COV
	} else {
# on pourrait y rajouter des args supplementaires pris dans operateur et valeur
	    set COV $Critere
	    set NoNomme [NoCo "MieuxNommer" $NoMayBe $COV]
	}
	set Commande "Tamis $NomTamisEntrant $Action $NoNomme"
	NommeEtStockeLeTamis $Commande
	
	set LesBons {}
	if {$ComTamisEntrant=="TamisInconnu"} { return {} }
	set ListeDeNoms [eval $ComTamisEntrant]
	set AutresArgs ""
	set SesArgs [info args $Critere]
	set nArgs [llength $SesArgs]
	if {$nArgs>1} { 
	    FaireLire "$Critere \{$SesArgs\} need [incr nArgs -1] additionnal arguments. Please give me them."
	    set AutresArgs [Entre]
	}

	foreach Nom $ListeDeNoms {
	    if {$AutresArgs==""} {
		set ValeurCalculee [eval $Critere $Nom]
	    } else {
		set ValeurCalculee [eval $Critere $Nom $AutresArgs]
	    }
	    lappend LesBons "$Nom $ValeurCalculee"
	}
	return $LesBons
    }
    FaireLire "Action $Action unknown in Tamis"
    return {}
}

proc AffecteListeDesPABs Liste {
    global MemoAffecteListeDesPABs
    global ListeDesPABs

    if {$Liste=="Reset"} {
	if { ! [info exists MemoAffecteListeDesPABs]} {
	    return [ListeDesPABs]
	}
	set ListeDesPABs $MemoAffecteListeDesPABs
	unset MemoAffecteListeDesPABs
	return $ListeDesPABs
    }

    if { ! [info exists MemoAffecteListeDesPABs]} {
	set MemoAffecteListeDesPABs [ListeDesPABs]
    }
    set ListeDesPABs $Liste
    return $ListeDesPABs    
}

proc ListeDesJumeauxRepresentatifs {} {
    return [JumeauRepresentatif "LaListeMerci"]
}

proc RechargeListeDesPABs {} {
    global ListeDesPABs

    if {[info exists ListeDesPABs]} { unset ListeDesPABs } 
    return [ListeDesPABs]
    
}

proc ListeDesPABs {{NouveauPAB ""}} {
    global ListeDesPABs

    if { ! [info exists ListeDesPABs]} { 
	ChargeLesPABs 
    }

    if {$NouveauPAB!="" && [lsearch -exact $ListeDesPABs $NouveauPAB]<0} {
	lappend ListeDesPABs $NouveauPAB
    }
    return $ListeDesPABs
}

proc ListeDesGLIMMERs {} {
    global ListeDesGLIMMERs

    if { ! [info exists ListeDesGLIMMERs]} { ChargeLesGLIMMERs }
    return $ListeDesGLIMMERs
}

proc ListeDesTRNAs {} {
    global ListeDesTRNAs

    if { ! [info exists ListeDesTRNAs]} { ChargeLesTRNAs }
    return $ListeDesTRNAs
}

proc ListeDesARNs {} {
    global ListeDesARNs

    if { ! [info exists ListeDesARNs]} { ChargeLesARNs }
    return $ListeDesARNs
}

proc ListeDeBoites {} {
    global ListeDeBoites

    if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
    return $ListeDeBoites
}

proc ListeDesTROUs {} {
    global ListeDesTROUs

    if { ! [info exists ListeDesTROUs]} { ChargeLesTROUs }
    return $ListeDesTROUs
}

proc ChargeListeDeBoites {} {
    global RepertoireDuGenome
    global ADN TDN RAC
    global ContenusDesBox
    global ListeDeBoites
    global ListeDesTRNAs
    global ListeDesARNs
    global ListeDesTROUs
    global ListeDesGLIMMERs
    global ListeDesFusions

    set ListeDeBoites {}
    if { ! [info exists ListeDesPABs]}     { ChargeLesPABs }
    if { ! [info exists ListeDesFusions]}  { ListeDesFusions }
    if { ! [info exists ListeDesTRNAs]}    { ChargeLesTRNAs }
    if { ! [info exists ListeDesARNs]}     { ChargeLesARNs }
    if { ! [info exists ListeDesTROUs]}    { ChargeLesTROUs }
    if { ! [info exists ListeDesGLIMMERs]} { ChargeLesGLIMMERs }
    return $ListeDeBoites
}

proc ChargeLesPABs {} {
    global ListeDesPABs
    global ListeDeBoites

#    if {[OnTraite "REFUNI" "NonStrict"]} { set ListeDesPABs {} ; set ListeDesBoites {} ; return {} }

    set FichierBornesDesPABs "[RepertoireDuGenome]/fiches/bornesdespabs"
    while { ! [file exists $FichierBornesDesPABs]} { CreeLaBaseOuLaCollection }

    set LesBornes [LesLignesDuFichier $FichierBornesDesPABs]
    set ListeDeBoites {}
    set ListeDesPABs {}
    foreach Ligne $LesBornes {
	if { ! [YaPABdans $Ligne] } { 
	    continue 
	}
	ExtraireDe $Ligne Nom Debut Fin Orient

	if {[regexp {\-([0-9]+)$} $Debut Match D] && [regexp {\-([0-9]+)$} $Fin Match F]} {
	    #rR on traite le cas Chr01-12345 Chr01-12389
	    set Long  [expr $F-$D+1]
	    set Frame [NomDeLaFrame [expr $D%3] $Orient]
	} else {
	    set Long  [expr $Fin-$Debut+1]
	    set Frame [NomDeLaFrame [expr $Debut%3] $Orient]
	}
	
	set  Boite        $Nom
	Box $Boite nom    $Nom
	Box $Boite orient $Orient
	Box $Boite frame  $Frame
	Box $Boite debut  $Debut
	Box $Boite fin    $Fin
	Box $Boite long   $Long
	lappend ListeDeBoites $Boite
	lappend ListeDesPABs $Nom
    }
    return $ListeDesPABs
}

proc ChargeLesTRNAs {} {
    global RepertoireDuGenome
    global ListeDeBoites
    global ListeDesTRNAs

    set ListeDesTRNAs {}

    if {[OnTraiteUneCollection]} { return {} }

    set FichierBornesDesTRNAs "$RepertoireDuGenome/fiches/bornesdestrnas"
    if {[file exists $FichierBornesDesTRNAs]} {
	set LesBornes [LesLignesDuFichier "$FichierBornesDesTRNAs"]
	set LireDansBornes 1
    } else {
	set FichierTRNAscan [lindex [glob -nocomplain "$RepertoireDuGenome/trnadir/tRNAscan*"] 0]
	if {$FichierTRNAscan != "" && \
		[OuiOuNon "Je peux prendre $FichierTRNAscan pour les tRNAs ?"]} {
	} else {
	    if { 1 || ! [OuiOuNon "Y a t-il un fichier tRNAscan quelque part ?"]} {
		return {}
	    } else {
		set FichierTRNAscan [ButineArborescence All]
		if {$FichierTRNAscan == ""} { return {} }
	    }
	}
	set LesBornes [LesLignesDuFichier "$FichierTRNAscan"]
	set LireDansBornes 0
    }


    set DejaVus {}
    set NombreDeLignesASauter 3
    foreach Ligne $LesBornes {
	if {$LireDansBornes} {
	    ExtraireDe $Ligne Nom Debut Fin Orient
	} else {
	    if { $NombreDeLignesASauter > 0 } { incr NombreDeLignesASauter -1 ;  continue }
	    scan $Ligne "%s %d %d %d %s %s %d %d %f" Bidon n Debut Fin Type AntiCodon IntronBegin IntronEnd CoveScore
	    set Nom "TRNA$Type$AntiCodon"
	    if { ! [regexp {[A-Z][a-z][a-z]} $Type] || \
		    ! [regexp {[ATGC][ATGC][ATGC]} $AntiCodon]} {
		FaireLire "$Nom n'est pas conforme ... faudra me dire comment je l'appelle."
		set Nom [Entre "TRNAXxxNNN"]
	    } 
	    set Orient "F"
	    if { [expr $Fin < $Debut] } {
		set Temp  $Debut
		set Debut $Fin
		set Fin   $Temp
		set Orient "R"
	    }
	}

	while {[lsearch $DejaVus $Nom] >= 0} {
	    if {[info exists Nieme($Nom)]} {
		incr Nieme($Nom)
	    } else {
		set Nieme($Nom) 2
	    }
	    set Nom "$Nom-[set Nieme($Nom)]"
	}
	lappend DejaVus $Nom 

	if {[regexp {\-([0-9]+)$} $Debut Match D] && [regexp {\-([0-9]+)$} $Fin Match F]} {
	    #rR on traite le cas Chr01-12345 Chr01-12389
	    set Long  [expr $F-$D+1]
	} else {
	    set Long  [expr $Fin-$Debut+1]
	}
	set Frame [NomDeLaFrame TRNA $Orient]
	
	set  Boite        $Nom
	Box $Boite nom    $Nom
	Box $Boite orient $Orient
	Box $Boite frame  $Frame
	Box $Boite debut  $Debut
	Box $Boite fin    $Fin
	Box $Boite long   $Long
	
	lappend ListeDeBoites $Boite
	lappend ListeDesTRNAs $Nom
    }
    if { ! $LireDansBornes && [OuiOuNon "Je sauve les tRNAs dans $FichierBornesDesTRNAs"]} {
	set Liste {}
	foreach TRNA $ListeDesTRNAs {
	    set Nom    [Box $TRNA nom]
	    set Orient [Box $TRNA orient]
	    set Debut  [Box $TRNA debut]
	    set Fin    [Box $TRNA fin]
	    lappend Liste "$Nom $Debut $Fin $Orient"
	}
	SauveLesLignes $Liste dans $FichierBornesDesTRNAs
    }
}


proc ChargeLesARNs {} {
    global RepertoireDuGenome
    global ListeDeBoites
    global ListeDesARNs

    set ListeDesARNs {}

    if {[file exists "$RepertoireDuGenome/fiches/bornesdesarns"]} {
	set LesBornes [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdesarns"]
	set LireDansBornes 1
    } else {
	if { ! [OnTraiteUnGenome]} { return {}}
	if { ! [file isdirectory "$RepertoireDuGenome/arndir"] && \
		[glob -nocomplain "$RepertoireDuGenome/fiches/*arn*"]=={}} { return {}}
 	if { ! [OuiOuNon "Y a t-il un fichier ARN quelque part ?" 0]} { return {} }
	set FichierARN [ButineArborescence All]
	if {$FichierARN == ""} { return {} }
	set LesBornes [LesLignesDuFichier "$FichierARN"]
	set LireDansBornes 0
    }

    foreach Ligne $LesBornes {
	if {$LireDansBornes} {
	    ExtraireDe $Ligne Nom Debut Fin Orient
	} else {
	    if { ! [regexp {\:} $Ligne]} { continue }
	    scan $Ligne "%s %s %d %s %d" Nom dp Debut Moins Fin
	    set Nom "ARN$Nom"

	    set Orient "F"
	    if { [expr $Fin < $Debut] } {
		set Temp  $Debut
		set Debut $Fin
		set Fin   $Temp
		set Orient "R"
	    }
	}

	if {[regexp {\-([0-9]+)$} $Debut Match D] && [regexp {\-([0-9]+)$} $Fin Match F]} {
	    #rR on traite le cas Chr01-12345 Chr01-12389
	    set Long  [expr $F-$D+1]
	} else {
	    set Long  [expr $Fin-$Debut+1]
	}
	set Frame [NomDeLaFrame ARN $Orient]
	
	set  Boite        $Nom
	Box $Boite nom    $Nom
	Box $Boite orient $Orient
	Box $Boite frame  $Frame
	Box $Boite debut  $Debut
	Box $Boite fin    $Fin
	Box $Boite long   $Long
	
	lappend ListeDeBoites $Boite
	lappend ListeDesARNs $Nom
    }
}

proc ChargeLesTROUs {} {
    global RepertoireDuGenome
    global ListeDesTROUs
    global ListeDeBoites
    global SansLesTrous

    set SansLesTrous 0

    if {[info exists SansLesTrous] && $SansLesTrous } {
	set ListeDesTROUs {}
	return $ListeDesTROUs
    }

    set ListeDesTROUs {}
    if { ! [file exists "$RepertoireDuGenome/fiches/bornesdestrous"]} { return $ListeDesTROUs }

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdestrous"] {

	ExtraireDe $Ligne Nom Debut Fin Orient

#	if {[NombreDeCopainsDansBlast $Nom] < 1} { continue }

	set Frame [string range $Nom [string length "TROUxxxx"] end]
	if {[regexp {[ABCN]} $Frame]} {
	    set Orient "F"
	} else {
	    set Orient "R"
	}
	set Long [expr $Fin-$Debut+1]

	set  Boite        $Nom
	Box $Boite nom    $Nom
	Box $Boite orient $Orient
	Box $Boite frame  $Frame
	Box $Boite debut  $Debut
	Box $Boite fin    $Fin
	Box $Boite long   $Long

	lappend ListeDeBoites $Boite
	lappend ListeDesTROUs $Nom
    }
    return $ListeDesTROUs
}

proc ChargeLesGLIMMERs {} {
    global ListeDeBoites
    global ListeDesGLIMMERs
    set ListeDesGLIMMERs {}

    set FichierBornesDesGlimmers "[RepertoireDuGenome]/fiches/bornesdesglimmers"
    if { ! [file exists $FichierBornesDesGlimmers]} { return $ListeDesGLIMMERs }

    set LesBornes [LesLignesDuFichier $FichierBornesDesGlimmers]
    foreach Ligne $LesBornes {
	if { ! [regexp "GLIMMER" $Ligne] } { continue }
	
	ExtraireDe $Ligne Nom Debut Fin Orient
	
	set Long  [expr $Fin-$Debut+1]
	set Frame [NomDeLaFrame [expr $Debut%3] $Orient]
	
	set  Boite        $Nom
	Box $Boite nom    $Nom
	Box $Boite orient $Orient
	Box $Boite frame  $Frame
	Box $Boite debut  $Debut
	Box $Boite fin    $Fin
	Box $Boite long   $Long
	lappend ListeDeBoites $Boite
	lappend ListeDesGLIMMERs $Nom
    }

    return $ListeDesGLIMMERs
}

proc ChargeLesInterGenes {} {
    global RepertoireDuGenome
    global ListeDesInterGenes

    if { ! [file exists "$RepertoireDuGenome/fiches/bornesdesintergenes"]} {
	RecreeLeFichierBornesDesInterGenes
    }

    foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdesintergenes"] {

	ExtraireDe $Ligne Nom Debut Fin Orient

	set Long [expr $Fin-$Debut+1]
	set Orient "F"
	set Frame  "I"

	set  Boite        $Nom
	Box $Boite nom    $Nom
	Box $Boite orient $Orient
	Box $Boite frame  $Frame
	Box $Boite debut  $Debut
	Box $Boite fin    $Fin
	Box $Boite long   $Long

	lappend ListeDesInterGenes $Boite
    }
    return $ListeDesInterGenes
}