proc ProtocoleDuProttfaAuMacsim {{Nom ""}} {

    Espionne "BlastPPourTous"
    BlastPPourTous                                     $Nom

    Espionne "DaedaluhitsDuBlastPPourTous"
    DaedalusHitsDuBlastPPourTous                       $Nom "EnProcessExterne"

    if {$Nom==""} {
	CreeLeFichierNombreDeCopainsDansBlast
    }

    Espionne "DbClustalPourTous"
    DbClustalPourTous                                  $Nom "daedalus"

    if {$Nom==""} {
	Espionne "CreeLesFichiersPhylos"
	CreeLesFichiersPhylos                          $Nom
    }

    Espionne "LeonEtMacsimPourTous"
    LeonEtMacsimPourTous                               $Nom

}

proc ProtocolePeroxisome {{Nom ""}} {
    if {$Nom==""} {
	set Bornes [UneNouvelleSequencePourGscope]
	if {$Bornes!=""} { scan $Bornes "%s" Nom }
    }
    Espionne "PsiBlastPPourTous"
    PsiBlastPPourTous                                  $Nom
    Espionne "DernierBlastDuPsiBlastPourTous"
    DernierBlastDuPsiBlastPourTous                     $Nom
    Espionne "DbClustalPourTous"
    DbClustalPourTous                                  $Nom
    Espionne "CreeLesFichiersPhylos"
    CreeLesFichiersPhylos                              $Nom
    Espionne "RemplaceAccessParOrganismeDansFichierPhylo"
    RemplaceAccessParOrganismeDansFichierPhyloPourTous $Nom
    Espionne "LeonEtMacsimPourTous"
    LeonEtMacsimPourTous                               $Nom
}

proc AfficheSortedDistances {NomOuFichier} {
    set LesDistances [PairwizeDistancesInMsf "SortedDistances" $NomOuFichier]
    return [Graphe $LesDistances]
}

proc AfficheReduceMsf {NomOuFichier {MinAB ""}} {
    set MSF [ReduceMsf $NomOuFichier "GetText" $MinAB]
    return [AfficheVariable $MSF "AvecEtudeMSFGrandeLargeur" $NomOuFichier]
}

proc ReduceMsf {NomOuFichier {FicOut ""} {MinAB ""}} {

    if {$FicOut==""} { set FicOut "GetText" }

    if {$MinAB==""} { set MinAB 0.2 }

    set Nom [file tail $NomOuFichier]
    if {[EstUnPAB $NomOuFichier]} {
	set Fichier "[RepertoireDuGenome]/msf/$Nom"
    } else {
	set Fichier $NomOuFichier
    }
    set TexteMsf [ContenuDuFichier $Fichier]
    if {[regexp "QUERY_PROTEIN" $TexteMsf]} {
	set Nom "QUERY_PROTEIN"
    }

    set LesAccess [PairwizeDistancesInMsf "AccessList" $Fichier] 
    set LesRejetes {}
    foreach A $LesAccess {
	set  Adist [PairwizeDistancesInMsf $Nom $A]
	if {$Adist==""} { continue }
	foreach B $LesAccess {
	    set  Bdist [PairwizeDistancesInMsf $Nom $B]
	    if {$Bdist==""} { continue }
	    if {$A>$B} { set PremAlpha $A } else { set PremAlpha $B } 
	    if {$Adist  > $Bdist} { set PlusLoin($A,$B) [set PlusLoin($B,$A) $A] }
	    if {$Bdist  > $Adist} { set PlusLoin($A,$B) [set PlusLoin($B,$A) $B] }
	    if {$Adist == $Bdist} { set PlusLoin($A,$B) [set PlusLoin($B,$A) $PremAlpha] }
	}
    }
    set I 0
    foreach A $LesAccess {
	incr I
	if {$A==$Nom} {continue}
	set Adist [PairwizeDistancesInMsf $Nom $A]
	if {$Adist==""} { continue }
	foreach B [lrange $LesAccess $I end] {
	    if {$B==$Nom} {continue}
	    set ABdist [PairwizeDistancesInMsf $A $B]
	    if {$ABdist==""} { continue }
	    if {$ABdist>$MinAB} { continue }
	    set Bdist [PairwizeDistancesInMsf $Nom $B]
	    if {$Bdist==""} { continue }
	    if {$PlusLoin($A,$B)==$A} { lappend LesRejetes $A } 
	    if {$PlusLoin($A,$B)==$B} { lappend LesRejetes $B }
	}
    }
    set LesRejetes [lsort -unique $LesRejetes]
    set NewMSF [MSFSelection $TexteMsf $LesRejetes "Out"]
    if {$FicOut=="GetText"} { return $NewMSF }
    return [Sauve $NewMSF dans $FicOut]
}

proc PairwizeDistancesInMsf {A {B ""} {Fichier ""}} {
    global PairwizeDistancesInMsf

    if {$A=="AccessList"} {
	set Fichier $B
	set B ""
    }

    if {$A=="SortedDistances"} {
	set Fichier $B
	set B ""
    }

    if {$Fichier=="" || \
	    [info exists PairwizeDistancesInMsf] && $PairwizeDistancesInMsf(Fichier)==$Fichier} {
	if {[info exists PairwizeDistancesInMsf($A,$B)]} { return $PairwizeDistancesInMsf($A,$B) }
	return ""
    }

    set PairwizeDistancesInMsf(Fichier) $Fichier
    set FicTmp [TmpFile "" "" "_"]
    file copy $Fichier $FicTmp
    if {[catch {exec clustalw -tree -outputtree=dist -infile=$FicTmp} Message]} {
	Warne "Error during PairwizeDistancesInMsf $Fichier\n \
		clustalw -tree -outputtree=dist -infile=$FicTmp\n \
		I got the message \n$Message"
	return ""
    }
    if { ! [file exists $FicTmp.dst]} {
	Warne "Error during PairwizeDistancesInMsf $Fichier\\n \
		clustalw -tree -outputtree=dist -infile=$FicTmp\n \
		The output file $FicTmp.dst doesn't exist"
	return ""
    }
    set L 0

    foreach Ligne [lrange [LesLignesDuFichier $FicTmp.dst] 1 end] {
	if { ! [regexp "^( |\t)" $Ligne]} {
	    scan $Ligne "%s" Access
	    set Ligne [StringSuivant " " dans $Ligne]
	    incr L
	    set TabAccess($L) $Access
	    lappend LesAccess $Access
	    lappend LesLs $L
	    set C 0
	}
	foreach Mot [LesMotsDeLaLigne $Ligne] {
	    incr C
	    set TabDist($L,$C) $Mot
	    lappend LesDistances $Mot
	}
    }
    if {[file exists $FicTmp]}     {file delete $FicTmp}
    if {[file exists $FicTmp.dst]} {file delete $FicTmp.dst}
    foreach L $LesLs {
	foreach C $LesLs {
	    set PairwizeDistancesInMsf($TabAccess($L),$TabAccess($C)) $TabDist($L,$C)
	}
    }
    set PairwizeDistancesInMsf(SortedDistances,) [lsort -real -unique $LesDistances]
    set PairwizeDistancesInMsf(AccessList,) $LesAccess
    return [PairwizeDistancesInMsf $A $B]
}

proc LoinToujoursTest {} {
    puts [LoinToujours 0.1]
    puts [LoinToujours 0.0001]
    puts [LoinToujours 0.01 Set]
    puts [LoinToujours 0.1]
    puts [LoinToujours 0.00001]
    puts [LoinToujours Reset]
    puts [LoinToujours 0.1]
    puts [LoinToujours NotUsed]
    puts [LoinToujours 0.0001]
    puts [LoinToujours 0.01 Set]
    puts [LoinToujours 0.1]
    puts [LoinToujours 0.00001]
    puts [LoinToujours Reset]
    puts [LoinToujours 0.1]
    puts [LoinToujours 0.00001]
}

proc LoinToujours {PN {Action ""}} {
    Wup "On peut vouloir prendre toutes les sequences lointaines"
    Wup "LoinToujours 0.001 Set       en fixe le seuil"
    Wup "LoinToujours bidon NotUsed   on repondra systematique non"
    Wup "LoinToujours bidon Reset           on annule tout pour le prochain usage"
    Wup "LoinTours PN                 repond PN>SeuilExpect"

    if {[OnTraiteMS2PH]} { return 0 }
    global LoinToujours

    if {$PN=="Reset" || $PN=="NotUsed"} { set Action $PN } 

    if {$Action=="Reset"} {
	if {[info exists LoinToujours]} { unset LoinToujours }
	return 0
    }
    if {$Action=="NotUsed"} {
	set LoinToujours(UseIt) 0
	return 0
    }
    if {$Action=="Set"} {
	if {[info exists LoinToujours]} { unset LoinToujours }
	set LoinToujours(UseIt) 1
	set LoinToujours(SeuilExpect) $PN
	return 1
    }
    if { ! [info exists LoinToujours(SeuilExpect)]} { set LoinToujours(SeuilExpect) 0.001 }

    if { ! [info exists LoinToujours(UseIt)]} {
	set LoinToujours(UseIt) [OuiOuNon "Do I take all sequences, even with expect > $LoinToujours(SeuilExpect)" 0]
    }
    if {$LoinToujours(UseIt)} { return [expr $PN>$LoinToujours(SeuilExpect)] }
    return 0
}

proc MounirDuBlast {NomOuFichier {FichierSortie ""} {SeuilExpect ""} {MaxListe ""}} {

    if {$SeuilExpect==""} { set SeuilExpect 0.001 }
    if {$MaxListe==""}    { set MaxListe 9999 }

    if {$FichierSortie==""} { set FichierSortie "GetText" }

    set Nom [file tail $NomOuFichier]
    if {[EstUnPAB $NomOuFichier]} {
	set Fichier "[RepertoireDuGenome]/blastp/$Nom"
    } else {
	set Fichier $NomOuFichier
    }
    DecortiqueBlast $Fichier $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN
    foreach BanqueId $lBanqueId PN $lPN {
	if {$PN>$SeuilExpect} { break }
	set PNde($BanqueId) $PN
    }
    set SortieMounir [exec MounirDuBlastP < $Fichier]
    set LesElus {}
    set n 0
    foreach Ligne [split $SortieMounir "\n"] {
	if {[incr n] > $MaxListe} { break }
	scan $Ligne "%s" BanqueId
	if { ! [info exists PNde($BanqueId)]} { break }
	set PN $PNde($BanqueId)
	if {$PN>$SeuilExpect} { break }
	lappend LesElus $BanqueId
    }
    if {$FichierSortie=="GetList"} { return $LesElus }

    set LeReduit [BlastReduit $Fichier $LesElus]
    set Reduit [join $LeReduit "\n"]
    if {$FichierSortie=="GetText"} { return $Reduit }
    if {$FichierSortie=="Show"} {
	return [AfficheVariable $Reduit "AvecSegAlignement" "MounirReducedOf_/$Nom"]
    }
    return [Sauve $Reduit dans $FichierSortie]
}

proc MsfDesTFAsPourSapPourTous {} {
    set RepMsfPourSap "[RepertoireDuGenome]/msfpoursap"
    if { ! [file exists $RepMsfPourSap]} { file mkdir $RepMsfPourSap }
    set RepTFAsPourSap "[RepertoireDuGenome]/tfaspoursap"
    foreach Nom [ListeDesPABs] {
	set InFile "$RepTFAsPourSap/$Nom"
	if { ! [file exists $InFile]} { continue }
	set OutFile "$RepMsfPourSap/$Nom"
	ConvertToMsf $InFile $OutFile
	Espionne [exec ls -l $OutFile]
    }
}

proc MsfDesMAFFTPourTous {} {
    set RepMsfMafft "[RepertoireDuGenome]/msfmafft"
    if { ! [file exists $RepMsfMafft]} { file mkdir $RepMsfMafft }
    set RepMafft "[RepertoireDuGenome]/mafft"
    foreach Nom [ListeDesPABs] {
	set InFile "$RepMafft/$Nom"
	if { ! [file exists $InFile]} { continue }
	set OutFile "$RepMsfMafft/$Nom"
	ConvertToMsf $InFile $OutFile
	Espionne [exec ls -l $OutFile]
    }
}

proc SelectPdbForRefXPourTous {} {
    set RepSap "[RepertoireDuGenome]/tfaspoursap"
    if { ! [file exists $RepSap]} { file mkdir $RepSap }
    set RepMafft "[RepertoireDuGenome]/mafft"
    foreach Nom [ListeDesPABs] {
	set InFile "$RepMafft/$Nom"
	if { ! [file exists $InFile]} { continue }
	set OutFile "$RepSap/$Nom"
	set Retour [SelectPdbForRefX $InFile $OutFile]
	Espionne "With $Nom I got >$Retour<"
    }
}

proc SelectPdbForRefX {InFile OutFile {Cutoff ""}  {MatBla ""} {LogFile ""}} {

    set BaliBaseDir "/workbench/julie/bb/src"

    if {$LogFile==""} { set LogFile "/dev/null" }
    if {$MatBla ==""} { set MatBla "$BaliBaseDir/id.bla" }
    if {$Cutoff ==""} { set Cutoff 30 }
    exec $BaliBaseDir/selectpdbforref1 $InFile $Cutoff $MatBla $OutFile > $LogFile

    if {[file exists $OutFile]} { return $OutFile }
    return ""
}

proc CreeLeFichierTFAsDesAccessDuBlastPPourTous {{RepTFAs ""} {SeuilExpect ""} {MaxListe ""}} {
    if {$SeuilExpect==""} { set SeuilExpect 0.001 }
    if {$MaxListe==""}    { set MaxListe "SansLimiteDeNombre" }
    if {$RepTFAs==""}     { set RepTFAs "[RepertoireDuGenome]/tfaspourmafft" }

    if { ! [file exists $RepTFAs]} {file mkdir $RepTFAs} 

    foreach Nom [ListeDesPABs] {
	set FichierBlast "[RepertoireDuGenome]/blastp/$Nom"
	set FichierTFAs  "$RepTFAs/$Nom"
	if { ! [file exists $FichierBlast]} { continue }
	if {[file exists $FichierTFAs]} { continue }
	DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN
	Espionne [CreeUnTFAsDesListesBidAccess $lBanqueId $lAccess $FichierTFAs]
    }
}

proc BlastTrieDuPsiBlastPourTous {} {
    set Rep "[RepertoireDuGenome]/blastptrie"
    if { ! [file exists $Rep]} { file mkdir $Rep }
    foreach Nom [ListeDesPABs] {
	set FicPsiBlast "[RepertoireDuGenome]/psiblastp/$Nom"
	if { ! [file exists $FicPsiBlast]} { continue }
	set FicBlastTrie "$Rep/$Nom"
	set BlastTrie [DernierBlastDuPsiBlast $FicPsiBlast "Trie"]
	if {$BlastTrie==""} { continue }
	Sauve $BlastTrie dans $FicBlastTrie
    }
}

proc PsiBlast {FichierTFA {FichierPsiBlast ""} {Banque ""} {Options ""}} {

    if {$Banque==""} { set Banque "/catalog/blast/protall" }

    if {$FichierPsiBlast==""} {
	regsub {\.[^\.]+$} FichierTFA "" FichierPsiBlast
	append FichierPsiBlast ".psiblast"
    }
    if {$Options==""} { set Options "-j 1 -F T" }
    if {[catch { exec blastpgp -i $FichierTFA -d $Banque $Options -o $FichierPsiBlast.encours } Message]} {
	Espionne $Message
	return ""
    }
    if {[file exists $FichierPsiBlast.encours]} {
	file rename $FichierPsiBlast.encours $FichierPsiBlast
	return $FichierPsiBlast
    }
    return ""
}

proc ShowLesBlastsDuPsiBlast {Fichier {Nieme ""}} {

    if {$Nieme==""} { set Nieme "All" ; set Trie "" } else { set Trie "Trie" }
    set Queue [file tail $Fichier]
    set LesBlasts [LesBlastsDuPsiBlast $Fichier $Nieme $Trie]
    
    if {$Nieme!="All"} {
	set LesBlasts [list $LesBlasts]
	set LesIiemes [list $Nieme]
    } else {
	set LesIiemes [NombresEntre 1 [llength $LesBlasts]]
    }
    foreach Blast $LesBlasts Iieme $LesIiemes {
	set Fen [AfficheVariable $Blast "AvecSegAlignement" "${Iieme}_iteration_of_Psi_Blast/$Queue"]
    }
    return $Fen
}

proc DernierBlastDuPsiBlastPourTous {{Nom ""}} {
    if {$Nom==""} {
	set Liste [ListeDesPABs]
    } else {
	set Liste [list $Nom]
    }
    set RepDernier "[RepertoireDuGenome]/blastpDernierDuPsi"
    file mkdir $RepDernier
    foreach Nom $Liste {
	set FichierDer "$RepDernier/$Nom"
	if {[file exists $FichierDer]} { continue } 

	set FichierPsi "[RepertoireDuGenome]/psiblastp/$Nom"
	if { ! [file exists $FichierPsi]} { continue } 

	set DernierBlast [LesBlastsDuPsiBlast $FichierPsi "end" "Trie"]
	if {$DernierBlast==""} { continue }
	Espionne [Sauve $DernierBlast dans $FichierDer]
    }
}

proc DernierBlastDuPsiBlast {FicPsiBlast {Trie ""}} {
  
    set DernierBlast [LesBlastsDuPsiBlast $FicPsiBlast "end" $Trie]
    return $DernierBlast
}

proc LesBlastsDuPsiBlast {Fichier {Nieme ""} {Trie ""}} {

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

    if {$Nieme==""} { set Nieme "All" }
    set DansEntete 1
    set DansFin 0
    set LaFin {}
    set LesBlasts {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {$DansFin || [regexp "  Database" $Ligne]} {
	    set DansFin 1
	    set DansEntete 0
	    lappend LaFin $Ligne
	    continue
	} 
	if {[regexp "Results from round" $Ligne]} {
	    set DansEntete 0
	    if {[info exists LeCourant]} {
		lappend LesBlasts $LeCourant
	    }
	    set LeCourant $LEntete
	    continue
	}
	if {$DansEntete} {
	    lappend LEntete $Ligne
	    continue
	}
	lappend LeCourant $Ligne
    }
    if {[info exists LeCourant]} {
	lappend LesBlasts $LeCourant
    }
    set LesBonBlasts {}
    foreach LeBlast $LesBlasts {
	LConcat LeBlast $LaFin
	lappend LesBonBlasts [join $LeBlast "\n"]
    }
    if {$Nieme=="All"} { return $LesBonBlasts }
    if {[regexp {^[0-9]+$} $Nieme]} { incr Nieme -1 }
    set BlastNonTrie [lindex $LesBonBlasts $Nieme]
    if {$Trie} {
	set BlastTrie [DecortiqueBlast $BlastNonTrie "SansSeuilExpect" "SansLimiteDeNombre" RetourneBlastTrie]
	return $BlastTrie
    }
    return $BlastNonTrie
}

proc TestBlastReduit {} {
    BlastReduit PGS542 [LesLignesDuFichier liste.txt] AEnlever
    exit
}

proc BlastReduit {NomOuFichier ListeDesHits {AGarder ""}} {

    if {$AGarder=="AEnlever"} { set AGarder 0 } else { set AGarder 1 }
    set AEnlever [expr  ! $AGarder]

    foreach Hit $ListeDesHits {
	scan $Hit "%s" BId
	set BID [string toupper $BId]
	if {$AGarder}  { set Garder($BID) 1 }
	if {$AEnlever} { set Enlever($BID) 1 }
    }


    if {[regexp "/" $NomOuFichier]} {
	set Fichier $NomOuFichier
    } else {
	set Nom $NomOuFichier
	set Fichier "[RepertoireDuGenome]/blastp/$Nom"
    }

    if { ! [file exists $Fichier]} { return {} }

    set AvantListe 1
    set DansListe 0
    set DansFin 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { $DansFin } {
	    lappend LeNouveau $Ligne
	    continue
	}
	if {[regexp "  Database:" $Ligne]} {
	    lappend LeNouveau $Ligne
	    set DansFin 1
	    continue
	}
	if { $AvantListe } {
	    if { [regexp "Sequences producing" $Ligne] } { set AvantListe 0 }
	    lappend LeNouveau $Ligne
	    set DansListe 1
	    set PremierBlanc 1
	    continue
	} 
	if {[regexp "^>" $Ligne]} {
	    scan $Ligne "%s %s" BId Access
	    regsub ">" $BId "" BId
	    set BID [string toupper $BId]
	    set ACCESS [string toupper $Access]

	    if {[info exists Garder($BID)] || [info exists Garder($ACCESS)]} {
		set GarderAlignement 1
		lappend LeNouveau $Ligne
	    } else {
		set GarderAlignement 0
	    }
	    continue
	}   
	if {[info exists GarderAlignement]} {
	    if {$GarderAlignement} {
		lappend LeNouveau $Ligne
	    }
	    continue
	}
	if {$DansListe} {
	    if { $PremierBlanc } {
		lappend LeNouveau $Ligne
		set DansListe 1
		set PremierBlanc 0
		continue
	    }
	    if { ! [regexp -nocase {[A-Z]} $Ligne]} {
		set DansListe 0
		lappend LeNouveau $Ligne
		continue
	    }
	    scan $Ligne "%s %s" BId Access
	    set BID [string toupper $BId]
	    set ACCESS [string toupper $Access]

	    if {$AEnlever && ! [info exists Enlever($BID)]} { set Garder($BID) 1 }

	    if {[info exists Garder($BID)] || [info exists Garder($ACCESS)]} {
		lappend LeNouveau $Ligne
	    }
	    continue
	}
    }
    return $LeNouveau
}

proc EstUnAccessSwissprot Access {
    if {[regexp -nocase "^SW\:" $Access]} { return 1 } else { return 0}
}

proc LesElusDuBlastPParBandelettesPourTous {{Source ""}} {
    foreach Nom [ListeDesPABs] {
	set LesElus [LesElusDuBlastPParBandelettes $Nom $Source]
	Espionne $LesElus
    }
}

proc LesElusDuBlastPParMounirPourTous {{Source ""}} {
    foreach Nom [ListeDesPABs] {
	set LesElus [LesElusDuBlastPParMounir $Nom $Source]
	Espionne $LesElus
    }
}

proc LesElusDuBlastPAuChoixPourTous {{Source ""}} {
    foreach Nom [ListeDesPABs] {
	set LesElus [LesElusDuBlastPAuChoix $Nom $Source]
	Espionne $LesElus
    }
}

proc LesElusDuBlastPParBandelettes {Nom {Source ""} {Show ""} {SeuilExpect ""} {LoinToujours ""}} {

    #rR On peut forcer a prendre les eloignes. (je ne sais plus pourquoi ...) 
    if {$LoinToujours!=""} {
	if {[regexp -nocase "NotUsed" $LoinToujours]} {
	    LoinToujours "NotUsed"
	} else {
	    LoinToujours $LoinToujours "Set"
	}
    }

    if {$SeuilExpect==""} { set SeuilExpect 0.001 }

    set NomOrigine $Nom
    set Nom [file tail $Nom]

    set NombreMiniDeProches 20
    set MaxNbElus 200
    if {[OnTraiteMS2PH]} {
	set MaxNbElus 9999
	set NombreMiniDeProches 1
    }

    if {$Show==""} { set Show "DontShow" }
    if {$Show=="Show"} { set Show 1 } else { set Show 0 }

    set NomOuFichier $Nom
    if { ! [EstUnPAB $Nom]} { set NomOuFichier $NomOrigine }
    set LesLBsEtLeursCandidats [LesBandelettesDuBlast $NomOuFichier $Source]

    set LesElus {}
    set TousLesProches {}
#    set DejaBascule 1
    set NbElus 0
    foreach {LB SesCandidats} $LesLBsEtLeursCandidats {
	catch {unset PremierSW}
	catch {unset PremierTout}
	catch {unset PremierPDB}
	foreach Candidat $SesCandidats {
	    scan $Candidat "%s %s %s %s %s %s" LogPN BId Access PN DE OX
	    if {[EstUnAccessPDB $BId]} {
		if { ! [info exists PremierPDB]} { set PremierPDB $BId }
		continue
	    }
	    if {[EstUnAccessSwissprot $BId]} {
		if { ! [info exists PremierSW]} { set PremierSW $BId }
	    }
	    if { ! [info exists PremierTout]} { set PremierTout $BId }		
	}
	set Capital ""
	if {       [info exists PremierSW]} {
	    set Capital $PremierSW
	} elseif { [info exists PremierTout]} {
	    set Capital $PremierTout
	} elseif { [info exists PremierPDB]} {
	    set Capital $PremierPDB
	}
	set NProchesPrisPourCetteBandelette 0
	foreach Candidat $SesCandidats {
	    set OX ""
	    scan $Candidat "%s %s %s %s %s %s" LogPN BId Access PN DE OX
	    lappend LesProches "$BId $Access $PN $OX"
#	    Espionne "$BId $PN"
	    set BonAPrendre [expr [LoinToujours $PN] || [EstUnAccessPDB $BId] || \
		    $PN<=$SeuilExpect && [string equal $BId $Capital]]
#	    Espionne "$BId $PN $BonAPrendre [EstUnAccessPDB $BId] "
	    if {$BonAPrendre} {
		lappend LesElus "$BId $Access $PN $OX"
		set NbElus [llength $LesElus]
		if {$NbElus > $MaxNbElus} { break }
	    }
	    if {$PN<=$SeuilExpect} {
		    lappend TousLesProches "$BId $Access $PN $OX"
	    } else {
		if { ! [info exists DejaBascule] && [llength $LesElus]<$NombreMiniDeProches} {
		    set DejaBascule 1
		    lappend TousLesProches "$BId $Access $PN $OX"
		    set LesElus $TousLesProches
		}
	    }
	}
	if {$NbElus > $MaxNbElus} { break }
    }
    if {$Show} {
	set Fen [AfficheUneSortieBlast $Nom]
	set LesBIds {}
	foreach Elu $LesElus {
	    scan $Elu "%s" BId
	    lappend LesBIds $BId
	}
	IllumineLaListe $LesBIds $Fen
#	FaireSavoir "On passe au suivant de $Nom"
#	destroy $Fen
#	global KduGraphe ; destroy [winfo parent $KduGraphe]
#	set Show [OuiOuNon "Do I continue to show the selected accesses ?"]
    }
    return $LesElus
}

proc LesElusDuBlastPParAuChoix {Nom {Source ""} {Show ""}} {

    JeMeSignale

    set Nom [file tail $Nom]

    set MaxNbElus 200

    if {$Show==""} { set Show "DontShow" }
    if {$Show=="Show"} { set Show 1 } else { set Show 0 }

    set LesElus [AuChoixDuBlast $Nom "GetList"]

    if {$Show} {
	set Fen [AfficheUneSortieBlast $Nom]
	set LesBIds {}
	foreach Elu $LesElus {
	    scan $Elu "%s" BId
	    lappend LesBIds $BId
	}
	IllumineLaListe $LesBIds $Fen
#	FaireSavoir "On passe au suivant de $Nom"
#	destroy $Fen
#	global KduGraphe ; destroy [winfo parent $KduGraphe]
#	set Show [OuiOuNon "Do I continue to show the selected accesses ?"]
    }
    return $LesElus
}

proc LesElusDuBlastPParMounir {Nom {Source ""} {Show ""}} {

    JeMeSignale

    set Nom [file tail $Nom]

    set MaxNbElus 200

    if {$Show==""} { set Show "DontShow" }
    if {$Show=="Show"} { set Show 1 } else { set Show 0 }

    set LesElus [MounirDuBlast $Nom "GetList"]

    if {$Show} {
	set Fen [AfficheUneSortieBlast $Nom]
	set LesBIds {}
	foreach Elu $LesElus {
	    scan $Elu "%s" BId
	    lappend LesBIds $BId
	}
	IllumineLaListe $LesBIds $Fen
#	FaireSavoir "On passe au suivant de $Nom"
#	destroy $Fen
#	global KduGraphe ; destroy [winfo parent $KduGraphe]
#	set Show [OuiOuNon "Do I continue to show the selected accesses ?"]
    }
    return $LesElus
}

proc LesBandelettesDuBlast {FichierOuNom {Source ""} {AvecSize ""} {OnGraphe ""}} {

    global OnGrapheLesBandelettes
    if { ! [info exists OnGrapheLesBandelettes]} { set OnGrapheLesBandelettes 0 }

    if {$OnGraphe==""} { set OnGraphe "DontGraphe" }
    if {$OnGraphe=="OnGraphe"} { set OnGraphe 1 } else { set OnGraphe 0 }

    set NombreDeBandelettes 40
    if {[OnTraiteMS2PH]} { set NombreDeBandelettes 100 }
    if {[PreFixe]=="RO"} { set NombreDeBandelettes 100 }
    set Nom [file tail $FichierOuNom]

    set MaxADecortiquer "SansLimiteDeNombre"
    set SeuilExpect "SansSeuilExpect"
    if {$AvecSize=="AvecSize"} { set AvecSize 1 } else { set AvecSize 0 }
    if {$AvecSize} {
	scan [TailleDuDescriptifDuBlastP] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect 
	set MaxADecortiquer [expr $MaxVoulus+$MaxPDB]
	global SeuilExpectPourJulie
	if {[info exists SeuilExpectPourJulie]} { set SeuilExpect $SeuilExpectPourJulie }
    }

    if {[regexp "/" $FichierOuNom]} {
	set Fichier $FichierOuNom
    } else {
	if {$Source==""} { set Source "blastp" }
	set Fichier "[RepertoireDuGenome]/$Source/$Nom"
    }
    if {$Source==""} { 
	if {[regexp "daedalus" $Fichier]} {
	    set Source "daedalushits"
	} else {
	    set Source "blast"
	}
    }


    if { ! [file exists $Fichier]} {
	FaireLire "$Fichier doesn't exist. I'll cancel LaSelectionDuBlast"
	return ""
    }
    set LesCandidats {}
    if {[regexp "daedalushits" $Source]} {
	set Texte [ContenuDuFichier $Fichier]
	set PN 0.0009876
	while 1 {
	    set BlastHit [ValeurDeLaBalise "BlastHit" Texte "Rogner" BH]
	    if {$BlastHit==""} { break }
	    set BanqueId $BH
	    set Access   $BH
	    set AccessOK $BH
	    set OldPN $PN
	    set ID [ValeurDeLaBalise "ID" BlastHit "NePasRogner"]
	    if {[regexp VARSPLIC $ID]} { continue }
	    set AC [ValeurDeLaBalise "AC" BlastHit "NePasRogner"]
	    set PN [ValeurDeLaBalise "PN" BlastHit "NePasRogner"]
	    if {$PN=="0.000999"} { set PN $OldPN }
	    set OX [ValeurDeLaBalise "OX" BlastHit "NePasRogner"]
	    set GN [ValeurDeLaBalise "GN" BlastHit "NePasRogner"]
	    set DE [ValeurDeLaBalise "DE" BlastHit "NePasRogner"]
	    set OS [ValeurDeLaBalise "OS" BlastHit "NePasRogner"]
	    set OC [ValeurDeLaBalise "OC" BlastHit "NePasRogner"]
	    set CandId [lindex [split $ID " "] 0]
	    set CandAc [lindex [split $AC " "] 0]
	    if {$CandId==""} { set CandId $BanqueId }
	    if {$CandAc==""} { set CandAc $Access }
	    if {$OS=="" && $OX!=""} { set OS [Tax $OX "Name"] } 
	    regsub -all " " $DE "_" BeauDE
	    set Candidat "$CandId $CandAc $PN $BeauDE $OX $OS $OC"
	    lappend LesCandidats $Candidat
	}
    }
    if {[regexp "blast" $Source]} {
	set n [DecortiqueBlast $Fichier $SeuilExpect $MaxADecortiquer \
		Query lBanqueId lAccess lDE lProfil lPN]
	foreach CandId $lBanqueId CandAc $lAccess PN $lPN DE $lDE {
	    regsub -all " " $DE "_" BeauDE
	    set Candidat "$CandId $CandAc $PN $BeauDE"
	    lappend LesCandidats $Candidat
	}
    }

    if {$LesCandidats=={}} { return "" }

    set LesPNs {}
    set LesLogPNs {}
    foreach Candidat $LesCandidats {
	set DE ""
	set OX ""
	scan $Candidat "%s %s %s %s %s" CandId CandAc PN DE OX
	set BonPN $PN
	if {$PN< 1.e-200} { set BonPN 1.e-200 }
	set LogPN [expr log10($BonPN)]
	lappend LesPNs $PN
	lappend LesLogPNs $LogPN
    }

    if {$OnGraphe || $OnGrapheLesBandelettes} {
	set K [Graphe $LesLogPNs]
	global KduGraphe ; set KduGraphe $K
    }

    if {$LesPNs=={}} {return {}}
    if {[llength $LesPNs]==1} {return [list [lindex $LesPNs 0] $LesCandidats]}
    set Prems [lindex $LesLogPNs 0]
    set Derns [lindex $LesLogPNs end]
    set Ecart [expr (1.*($Derns-$Prems))/$NombreDeBandelettes]
    set L $Prems
    while {$L<$Derns} {
	lappend LesLimites $L
	set L [expr $L + $Ecart]
    }
    lappend LesLimites 999999
    set LesLimitesHautes [lrange $LesLimites 1 end]
    set LB [lindex $LesLimites 0]
    set LH [lindex $LesLimitesHautes 0]

    set Compte -4
    set i 0
    foreach LogPN $LesLogPNs Candidat $LesCandidats {
	incr Compte
	while 1 {
	    if {$LB<=$LogPN && $LogPN<$LH} { break }
	    if {[incr i] >= [llength $LesLimites]} { break }
	    set LB [lindex $LesLimites $i]
	    set LH [lindex $LesLimitesHautes $i]
	}
	if { ! [info exists LesCandidatsPour($LB)]} {
	    lappend LesLBs $LB
	    lappend LesChoixX $LogPN $LogPN $LogPN
	    lappend LesChoixY $Compte [expr $Compte +1] [expr $Compte +2]
	}
	lappend LesCandidatsPour($LB) "$LogPN $Candidat"
    }
    if {$OnGraphe || $OnGrapheLesBandelettes} {
	Graphe $LesChoixY $LesChoixX $K "red"
	Graphe [lrange $LesLimites 0 end-1] "" $K "green"
    }
    foreach LB $LesLBs {
	if { ! [info exists LesCandidatsPour($LB)]} { continue }
	set SesCandidats {}
	foreach Candidat [set LesCandidatsPour($LB)] {
	    lappend SesCandidats $Candidat
	}
	lappend LesLBsEtLeursCandidats $LB $SesCandidats
    }
    return $LesLBsEtLeursCandidats
}