#rR gscope_aligne.tcl

proc LectureSegAli {Access SQ OS SegAli} {
    set ListeDesHomologues {}
    set StoreConservation 0
    set SS ""
    foreach Ligne [lrange $SegAli 0 end-2] Ligne2 [lrange $SegAli 1 end-1] Ligne3 [lrange $SegAli 2 end] {
	if {0 && $Access=="WP_049995565.1"} { Espionne $Ligne }
	if {$StoreConservation} {
	    append SeqConse [string range $Ligne $D $F]
	    set StoreConservation 0
	}
	if {[regexp {Length *= *([0-9]+)} $Ligne Match Length]} {
	    if {$SS==""} { set SS [string repeat "?" $Length] }
	    continue
	}
	if { [regexp "^ Identities =" $Ligne] } {
	    set Identities [StringApres "Identities =" dans $Ligne]
	    set Positives  [StringApres "Positives ="  dans $Ligne]
	    scan $Identities "%d/%d" nId nTotal
	    scan $Positives  "%d/%d" nPo nTotal
	}
	if { [regexp "^ Score =" $Ligne] || $Ligne=="FinSegAli" } {
	    if {[info exists Score]} {
		if {[info exists DebutQuery] && [info exists DebutSbjct]} {
		    incr nCops
		    incr nCopsDansCetteSequence
		    set Homologie [list $Access $nCops $nCopsDansCetteSequence $OS $Score $Expect $DebutQuery $FinQuery $DebutSbjct $FinSbjct $SeqQuery $SeqConse $SeqSbjct]
		    lappend ListeDesHomologues $Homologie
		}
		unset Score
		if { $Ligne=="FinSegAli"} { break }
	    }
	    
	    set Score [FloatApres "Score =" dans $Ligne]
	    if {[regexp "Expect =" $Ligne]} { 
		set Expect [PNApres "Expect =" dans $Ligne]
	    }
	    if {[regexp {Expect\([0-9]\) =} $Ligne Match]} { 
		set Expect [PNApres $Match dans $Ligne]
	    }
	    if { ! [info exists Expect]} {
		Warne "$Ligne\nwithout Expect ... I break"
		break
	    }
	    if {[info exists DebutQuery]} { unset DebutQuery }
	    if {[info exists DebutSbjct]} { unset DebutSbjct }
	    #if {[expr $Expect > $SeuilDuBlastN]} { break }
	}
	if {[regexp "^Query:?" $Ligne] } {
	    if { ! [info exists DebutQuery]} {
		set SeqQuery ""
		set KeyQ "Query"
		if {[regexp "Query:" $Ligne]} { set KeyQ "Query:" }
		set DebutQuery [IntegerApres $KeyQ dans $Ligne]
		set SeqConse ""
	    }
	    
	    regexp -nocase -indices {^(Query|Sbjct):? +[0-9]+ +([A-Z\-])} $Ligne IndicesDebut
	    set D [lindex $IndicesDebut 1]
	    regexp -nocase -indices {([A-Z\-] +[0-9]+) *$}                $Ligne IndicesFin
	    set F [lindex $IndicesFin 0]
	    
	    regexp -nocase -indices {^(Query|Sbjct):? +[0-9]+ +([A-Z\-])} $Ligne3 IndicesDebut3
	    set D3 [lindex $IndicesDebut3 1]
	    regexp -nocase -indices {([A-Z\-] +[0-9]+) *$}                $Ligne3 IndicesFin3
	    set F3 [lindex $IndicesFin3 0]
	    #rR c'est trop complique ... il faut creer les séquences dans une autre boucle ...
	    
	    set SeqDeLaLigne [string range $Ligne $D $F]
	    append SeqQuery $SeqDeLaLigne
	    set FinQuery [IntegerEnFin de $Ligne]
	    set StoreConservation 1
	    regsub -all {\-} $SeqDeLaLigne "" SeqDeLaLigneSansGap
	    set DQ [expr [IntegerApres $KeyQ dans $Ligne]]
	    set FQ $FinQuery
	    set SQ [string replace $SQ [expr $DQ-1] [expr $FQ-1] $SeqDeLaLigneSansGap]
	    set FinQueryPrevious $FinQuery
	}
	if {[regexp "^Sbjct:?" $Ligne] } {
	    if { ! [info exists DebutSbjct]} {
		set SeqSbjct ""
		set Key "Sbjct"
		if {[regexp "Sbjct:" $Ligne]} { set Key "Sbjct:" }
		set DebutSbjct [expr [IntegerApres $Key dans $Ligne]] ; #rR y avait aussi + Offset
	    }
	    set SeqDeLaLigne [string range $Ligne $D $F]
	    append SeqSbjct $SeqDeLaLigne
	    regsub -all {\-} $SeqDeLaLigne "" SeqDeLaLigneSansGap 
	    set FinSbjct [expr [IntegerEnFin de $Ligne]] ; #rR y avait aussi + Offset
	    set DS [expr [IntegerApres $Key dans $Ligne]]
	    set FS $FinSbjct
	    set SS [string replace $SS [expr $DS-1] [expr $FS-1] $SeqDeLaLigneSansGap]
	    set FinSubjctPrevious $FinSbjct
	}
    }
    if {0 && $Access=="WP_049995565.1"} { EspionneL $ListeDesHomologues ; Espionne $Access}
    return [list $SQ $SS $Length $ListeDesHomologues]
}


proc ConcatAlignments {OutFile args} {
    set I 0
    set LeTotal {}
    foreach F $args {
	incr I
	foreach Ligne [LesLignesDuFichier $F] {
	    regsub "^>" $Ligne ">${I}_" Ligne 
	    lappend LeTotal $Ligne
	}
    }
    return [SauveLesLignes $LeTotal dans $OutFile]
}

proc OnVireLesMonstresLointains {{Valeur ""}} {
    global OnVireLesMonstresLointains
    if {$Valeur!=""} { return [set OnVireLesMonstresLointains $Valeur] }
    if {[info exists OnVireLesMonstresLointains]} { return $OnVireLesMonstresLointains }
    set OnVireLesMonstresLointains 0
    return $OnVireLesMonstresLointains
}

proc MacsimExiste {} {
    return [file exists "[RepertoireDuGenome]/macsimXml"]
}

proc LesGrosManquants {} {
    foreach Nom [ListeDesPABs] {
	set FichierMsf "[RepertoireDuGenome]/msf/$Nom"
	set FichierLeo "[RepertoireDuGenome]/msfLeon/$Nom"
	set FichierRsf "[RepertoireDuGenome]/macsimRsf/$Nom"
	set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
	if {[file exists $FichierRsf]} { continue }
	if { ! [file exists $FichierMsf]} { continue }
	Espionne "$Nom [file exists $FichierLeo] [file exists $FichierRsf] [file size $FichierMsf]"
    }
    exit
}

proc MAFFTPourTous {{RepTFAs ""} {RepMAFFT ""} {Keep ""}} {

    if {$Keep=="OverWrite"} { set Keep 0 }
    if {$Keep=="Keep"} { set Keep 1 }
    if {$Keep==""} { set Keep [OuiOuNon "Do I keep existing files ?"] } 

    if {$RepTFAs==""} { set RepTFAs "[RepertoireDuGenome]/tfaspourmafft" }
    if {$RepMAFFT==""} { set RepMAFFT "[RepertoireDuGenome]/mafft" }

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

    foreach Nom [ListeDesPABs] {
	set FichierTFAs "$RepTFAs/$Nom"
	if { ! [file exists $FichierTFAs]} { continue }
	set FichierMAFFT "$RepMAFFT/$Nom"
	if {$Keep && [file exists $FichierMAFFT]} { continue }
	set Retour [MAFFT $FichierTFAs $FichierMAFFT] 
	Espionne "I run MAFFT on $Nom and got >$Retour<"
    }
    
}

proc MAFFT {FichierTFAs {FichierMAFFT ""}} {

    if {$FichierMAFFT==""} {
	regsub {\.tfa(|s)$} $FichierTFAs "" FichierMAFFT
	append FichierMAFFT ".mafft"
    }

    set VraiFichierTFAs $FichierTFAs
    if { ! [regexp "^/" $FichierTFAs]} { set VraiFichierTFAs "[pwd]/$FichierTFAs" }

    set VraiFichierMAFFT $FichierMAFFT
    if { ! [regexp "^/" $FichierMAFFT]} { set VraiFichierMAFFT "[pwd]/$FichierMAFFT" }

    NousAllonsAuBoulot
    set RepDessus [pwd]

    set RepMAFFT "[TmpFile MAFFT .]"
    file mkdir $RepMAFFT 
    cd $RepMAFFT


    set Racine [file tail $VraiFichierTFAs]
    file copy $VraiFichierTFAs $Racine.in

    set OK 1
    while 1 {
	if {[catch { exec /biolo/mafft/bin/sextet5 < $Racine.in >& /dev/null } Message]} {
	    FaireLire "MAFFT failed running 'sextet5' with message \n$Message"	
	    set OK 0
	    break
	}
	if {[catch { exec /biolo/mafft/bin/tbfast  -FAx < $Racine.in >& /dev/null } Message]} {
	    FaireLire "MAFFT failed running 'tbfast -FAx ...' with message \n$Message"
	    set OK 0
	    break
	}
	if {[catch { exec /biolo/mafft/bin/tbfast  -JFAx < pre > $Racine.out 2> $Racine.log } Message]} {
	    FaireLire "MAFFT failed running 'tbfast -JFAx ...' with message \n$Message"
	    set OK 0
	    break
	}
	break
    }
    if { $OK } {
	if {[file exists $Racine.out]} { file rename -force $Racine.out $VraiFichierMAFFT }
	cd $RepDessus
	foreach F [glob -nocomplain $RepMAFFT/*] {
	    file delete -force $F
	}
	file delete $RepMAFFT
    }
    OnRevientDuBoulot
    if { ! $OK } { return "" }
    return [ConvertToMsf $FichierMAFFT $FichierMAFFT]
}

proc ExecuteMacsim {FichierMsf FichierRsf} {
    Wup "On retourne vide si ca se passe bien, Message d'erreur si non"
#    exec /biolo/macsim/macsim $FichierMsf $FichierRsf
    set Nom [file tail $FichierMsf]
    regsub {\..*} $Nom "" Nom
    if {$Nom=="HSAP08771"} {
	Espionne "ExecuteMacsim $FichierMsf $FichierRsf \nen [pwd]"
	set RepTest "/genomics/link/CilioCarta/test"
	if {[catch {exec $RepTest/mon_macsim  $FichierMsf $FichierRsf >& $RepTest/$Nom.log } Message]} {
	    return $Message
	}
	return ""
    }
Espionne "/biolo/macsim/macsim $FichierMsf $FichierRsf"
    if {[catch {exec /biolo/macsim/macsim $FichierMsf $FichierRsf >& /dev/null } Message]} { return $Message }
    return ""
}

proc LeonEtMacsimPourTous {{Liste ""} {Keep ""} {SqueezeLeon ""}} {

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

    set RepLeo "[RepertoireDuGenome]/msfLeon"
    set RepLog "[RepertoireDuGenome]/leonLog"
    set RepRsf "[RepertoireDuGenome]/macsimRsf"
    set RepXml "[RepertoireDuGenome]/macsimXml"
    if {$SqueezeLeon} {
	set RepLeo "[RepertoireDuGenome]/msf"
    }
    if { ! [file exists $RepLeo]} {file mkdir $RepLeo}
    if { ! [file exists $RepLog]} {file mkdir $RepLog}
    if { ! [file exists $RepRsf]} {file mkdir $RepRsf}
    if { ! [file exists $RepXml]} {file mkdir $RepXml}

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

    if {[regexp "^StartWith" $Liste]} {
	set Premier [StringApres "StartWith" dans $Liste]
	set Liste [ListeDesPABs]
	set I [lsearch $Liste $Premier]
	set Liste [lrange $Liste $I end]
    } else {
	if {$Liste==""} { set Liste [ListeDesPABs] }
	if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
    }

    foreach Nom $Liste {
	Espionne "LeonEtMacsim s'occupent de $Nom"
	set FichierMSF  "[RepertoireDuGenome]/msf/$Nom"

	if { ! [file exists $FichierMSF]} { continue }
	if {[file size $FichierMSF] < 50} { continue }
	set FichierLeo "$RepLeo/$Nom"
	set FichierLog "$RepLog/$Nom"
	set FichierRsf "$RepRsf/$Nom"
	set FichierXml "$RepXml/$Nom"

	set TexteMsf [ContenuDuFichier $FichierMSF]

	set Query $Nom
	if {[regexp "QUERY_PROTEIN" $TexteMsf]} {
	    set Query "QUERY_PROTEIN"
	}

	if { ! [regexp "Name: $Query" $TexteMsf]} {
	    if { ! [regexp { Name: ([^ ]+)} $TexteMsf Match BetterQuery]} {
		set MonMessge "I can't find the query in $FichierMSF\nI'll skip"
		append MonMessage "\n$FichierLeo was not created by Leon ...  Bouhhh !" 
		AppendAuFichier $FichierLog $MonMessage
		Warne $MonMessage
		continue
	    }
	    Warne "I choose the first access $Query as query." 
	    set Query $BetterQuery
	}

	regsub ".rsf$" $FichierRsf "" FichierRsfSansExtension 
	if { $Keep && [file exists $FichierRsfSansExtension]} { continue }
	if { $Keep && [file exists $FichierRsf]} { continue }
	
	if {[PasTouche $Nom]} { continue }

	set CommandeLeon "leonbis"                      ; #rR depuis 2017/09/18 **************************

	set OnTeste [OnTraite "TestUniref"]
	if {0 && $OnTeste} { set CommandeLeon "/home/julie/LEON2/leon2.tcsh" }

	if { ! [file exists $FichierLeo]} {
	    if {[file exists $FichierLog]} { file delete $FichierLog }
	    set FichierLeoXml $FichierLeo.xml
	    if {[file exists $FichierLeoXml]} { file delete $FichierLeoXml }
	    Espionne "$CommandeLeon $FichierMSF $Query $FichierLeo $FichierLog"
	    exec $CommandeLeon $FichierMSF $Query $FichierLeo $FichierLog 
	}

	if {[file exists $FichierXml]} { file delete $FichierXml }
	if {[file exists $FichierRsf]} { file delete $FichierRsf }

	if { ! [file exists $FichierLeo]} {
	    set MonMessage "$FichierLeo was not created by Leon ...  Bouhhh !" 
	    AppendAuFichier $FichierLog $MonMessage
	    Warne $MonMessage
	    FinPasTouche $Nom
	    continue
	}    
	ConvertToOneHundred $FichierLeo $FichierLeo

	if { ! $OnTeste } {
	    NousAllonsAuBoulot
	    set FichierRsfLog "$FichierRsf.log"
	    if {[file exists $FichierRsfLog]} {file delete $FichierRsfLog} 
	    Espionne "ExecuteMacsim $FichierLeo $FichierRsf"
	    set Message [ExecuteMacsim $FichierLeo $FichierRsf]
	    OnRevientDuBoulot
	    set FichierRsfRsf "$FichierRsf.rsf"
	    set FichierRsfXml "$FichierRsf.xml"
	    if {[file exists $FichierRsfXml]} {
		file rename -force $FichierRsfXml $FichierXml
	    }
	    if { ! [file exists $FichierRsfRsf]} {
		set MonMessage "$FichierRsfRsf was not created. I got the message\n$Message"
		Warne $MonMessage
		AppendAuFichier $FichierRsfLog $MonMessage
	    } else {
		file rename -force $FichierRsfRsf $FichierRsf
		if {[file exists $FichierRsfLog]} { file delete $FichierRsfLog }
		Espionne "$FichierRsf is OK !"
	    }
	}
	FinPasTouche $Nom
    }
}

proc TailleDesSequencesAAligner {{Liste ""}} {

    set EnDetails 0
    if {$Liste==""} { set Liste [ListeDesPABs] }
    if {[EstUnPAB $Liste]} {
	set EnDetails 1
	set Liste [list $Liste]
	set LesLongueursAccess {}
    }
    foreach Nom $Liste {
	set Fichier "[RepertoireDuGenome]/tfasdescopains/$Nom"
	if { ! [file exists $Fichier]} { continue }
	set MinLong 999999
	set MaxLong 0
	set LesLongueurs {}
	foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $Fichier $Access]
	    set Long [string length [QueLaSequenceDuTexteTFA $TFA]]
	    lappend LesLongueurs $Long
	    if {$EnDetails} {
		set Entete [EnteteDuTexteTFA $TFA]
		lappend LesLongueursAccess "$Long $Entete"
	    }
	    set MinLong [Mini $MinLong $Long]
	    set MaxLong [Maxi $MaxLong $Long]
	}
	set LesLongueurs [lsort -integer $LesLongueurs]
	if {$EnDetails} {
	    set LesLongueursAccess [lsort -index 0 -integer $LesLongueursAccess]
	    return [AfficheVariable [join $LesLongueursAccess "\n"] \
		    "AvecFetch" "SequenceLengthesOf/$Fichier"]
	}
	if {$MaxLong<1000} { continue }
	lappend ToutesLesLongueurs "$Nom $MaxLong"
    }
    if {$EnDetails} { exit }
    set ToutesLesLongueurs [lsort -index 1 -integer $ToutesLesLongueurs]
    SauveLesLignes $ToutesLesLongueurs dans "[RepertoireDuGenome]/fiches/toutesleslongueurs"
    exit
}

proc ConserveLesDomaines {FichierMSF FichierBornes Ref NouveauFichierMSF} {
    global TmpTFAsDuMSFMemo NomDuFichierMSFMemo
    if {[info exists TFAsDuMSFMemo] && $NomDuFichierMSFMemo==$FichierMSF} {
	set TmpTFA $TmpTFAsDuMSFMemo
    } else { 
	set TFAs [CreeLeTFAsDuMSF $FichierMSF]
	set TmpTFAs [Sauve $TFAs dans [TmpFile]]
	set TmpTFAsDuMSFMemo $TmpTFAs
	set NomDuFichierMSFMemo $FichierMSF
    }
    set LesBornesGlobales {}
    set LesBornesDesManquants [list 1]
    foreach Ligne [LesLignesDuFichier $FichierBornes] {
	if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
	scan $Ligne "%d %d" D F
	set DG [PositionDansMSF Global $FichierMSF $D $Ref]
	set FG [PositionDansMSF Global $FichierMSF $F $Ref]
	Espionne "$DG $FG"
	lappend LesBornesDesManquants [expr $DG-1]
	lappend LesBornesDesManquants [expr $FG+1]
	lappend LesBornesGlobales $DG $FG
    }
    lappend LesBornesDesManquants "end"

    if {[file exists bornes_des_manquants]} { file delete bornes_des_manquants }
    foreach {A B} $LesBornesDesManquants {
	AppendAuFichier bornes_des_manquants "$A $B"
    }

    foreach Access [LaSequenceDuTFAs $TmpTFAs LaListeDesAccess] {
	set Seq [QueLaSequenceDuTexteTFA [LaSequenceDuTFAs $TmpTFAs $Access]]
#	regsub -all {\.} $Seq "-" Seq
	set LesZones {}
	foreach {D F} $LesBornesGlobales {
	    set Zone [string range "x$Seq" $D $F]
	    Espionne "$D $F $Zone"
	    lappend LesZones $Zone
	}
	set NouvSeq [join $LesZones "-"]
	set NouvTFA [SequenceFormatTFA $NouvSeq "$Access" "protbrut"]
	lappend LesTFAs $NouvTFA
    }
    regsub ".msf$" $NouveauFichierMSF "" NouveauFichierTFAs
    append NouveauFichierTFAs ".tfas"
    set NouveauFichierTFAs [SauveLesLignes $LesTFAs dans $NouveauFichierTFAs]
    return [ConvertToMsf $NouveauFichierTFAs $NouveauFichierMSF]
}

proc AfficheLeNombreDeResidusDansLesDomaines {FichierMSF FichierBornes} {
    foreach Ligne [LesLignesDuFichier $FichierBornes] {
	scan $Ligne "%s %s" D F 
	set LesComptes [LeNombreDeResidusDansLeDomaine $FichierMSF $D $F]
	EspionneL $LesComptes
	foreach Compte $LesComptes {
	    scan $Compte "%s %d" Access nRes
	    if { ! [info exists DejaVu($Access)]} { lappend LesAccess $Access }
	    set DejaVu($Access) 1
	    lappend LesResultats($Access) $D $F $nRes 
	}
    }
    foreach Access $LesAccess {
	set Ligne [format "%-10s" $Access]
	foreach {D F nRes} [set LesResultats($Access)] {
	    append Ligne [format "%5s-%4s=%4s  " $D $F $nRes]
	}
	lappend LesLignes $Ligne
    }
    return [AfficheVariable [join $LesLignes "\n"] "" "ResidueCountOf_$FichierMSF"]
    
}

proc LeNombreDeResidusDansLeDomaine {FichierMSF {D -1} {F end}} {
    set TFAs [CreeLeTFAsDuMSF $FichierMSF]
    set TmpTFAs [Sauve $TFAs dans [TmpFile]]
    set Sortie {}
    if { ! [regexp "end" $D]} { incr D -1}
    if { ! [regexp "end" $F]} { incr F -1}
    foreach Access [LaSequenceDuTFAs $TmpTFAs LaListeDesAccess] {
	set Seq [QueLaSequenceDuTexteTFA [LaSequenceDuTFAs $TmpTFAs $Access]]
	set Zone [string range $Seq $D $F]
	regsub -all {\.|\-} $Zone "" ZoneSansPoint
	set nRes [string length $ZoneSansPoint]
	lappend Sortie [format "%-10s %5d %s---%s" $Access $nRes [string range $ZoneSansPoint 0 4] [string range $ZoneSansPoint end-4 end]]
    }
#    file delete -force $TmpTFAs
    return $Sortie
}

proc DansAlignementPositionAbsolue {Pos Access {FichierMsf ""}} {
    return [DansAlignementPositionAutreDe "Relative" $Pos $Access $FichierMsf]
}

proc DansAlignementPositionRelative {Pos Access {FichierMsf ""}} {
    return [DansAlignementPositionAutreDe "Absolue" $Pos $Access $FichierMsf]
}

proc DansAlignementPositionAutreDe {RouA Pos Access {FichierMsf ""}} {
    Wup "On a generalise ici le PositionAutreDe en memorisant pour tous les access du Msf"
    global DAPAD
    if {$FichierMsf=="" && [info exists DAPAD(FichierMsf)]} {
	FaireLire "DansAlignementPositionAutreDe needs 4 params for its first call"
	return -1
    }
    if {$FichierMsf!="" &&   [info exists DAPAD(FichierMsf)] && $FichierMsf!=$DAPAD(FichierMsf)} { unset DAPAD }
    if {$FichierMsf!="" && ! [info exists DAPAD(FichierMsf)]} {
	set DAPAD(FichierMsf) $FichierMsf
	set n [DecortiqueUnMSF $FichierMsf LesNomsDesSequencesDansLOrdre Sequences]
	if {$n<=0} { return -1 }
	foreach NomDeSequence $LesNomsDesSequencesDansLOrdre {
	    set SeqGap [set Sequences($NomDeSequence)]
	    foreach {K V} [PositionAutreDe "GetArray" 0 $SeqGap] {
		set DAPAD($K,$NomDeSequence) $V
	    }
	}
    }
    if {[info exists DAPAD($RouA,$Pos,$Access)]} { return $DAPAD($RouA,$Pos,$Access) }
    return -1
}

proc PositionAbsolueDansAlignement {Pos {SeqGap ""}} {
    return [PositionAutreDe "Relative" $Pos $SeqGap]
}

proc PositionRelativeDansAlignement {Pos {SeqGap ""}} {
    return [PositionAutreDe "Absolue" $Pos $SeqGap]
}

proc PositionAutreDe {RouA Pos {SeqGap ""}} {
    global PositionAutreDe

    Wup "positions start at 1"
    Wup "PositionAutreDe Relative X Seq   gives the abs (gapped) pos corresponding to rel (no gap) pos X"
    Wup "the Absolute of a Relative is always defined"
    Wup "the Relative of an Absolute is the previous existing one (0 if begin)"
    Wup "RouA can be GetArray"

    if {$SeqGap!=""} {
	if {[info exists PositionAutreDe]} { unset PositionAutreDe }
	regsub -all -nocase {[^A-Z]} $SeqGap "" Seq
	set PosRelative 0
	set PosAbsolue 0
	foreach C [split $SeqGap ""] {
	    incr PosAbsolue
#	    if {[regexp -nocase {[A-Z]} $C]} 
            if {$C ne "." && $C ne "-"} {
		incr PosRelative
		set PositionAutreDe(Relative,$PosRelative) $PosAbsolue
	    }
	    set PositionAutreDe(Absolue,$PosAbsolue) $PosRelative
	}
    }
    if {$RouA=="GetArray"} { return [array get PositionAutreDe] }
    if {[info exists PositionAutreDe($RouA,$Pos)]} { return $PositionAutreDe($RouA,$Pos) }
    return -1
}

proc EquivalentDansMSF {FichierMSF Pos Ref Autre} {
    set G  [PositionDansMSF Global $FichierMSF $Pos $Ref]
    return [PositionDansMSF Local  $FichierMSF $G $Autre]
}

proc PositionDansMSF {LoGlo FichierMSF Connu Access} {
    global TmpTFAsDuMSFMemo NomDuFichierMSFMemo
    if {[info exists TmpTFAsDuMSFMemo] && $NomDuFichierMSFMemo==$FichierMSF} {
	set TmpTFAs $TmpTFAsDuMSFMemo
    } else { 
	set TFAs [CreeLeTFAsDuMSF $FichierMSF]
	set TmpTFAs [Sauve $TFAs dans [TmpFile]]
	set TmpTFAsDuMSFMemo $TmpTFAs
	set NomDuFichierMSFMemo $FichierMSF
    }
    set TFA [LaSequenceDuTFAs $TmpTFAs $Access]
    set Seq [QueLaSequenceDuTexteTFA $TFA]
    set L 0
    set G 0
    foreach C [split $Seq ""] {
	if {$C!="-" && $C!="."} { incr L }
	incr G
	if {$LoGlo=="Local"  && $G==$Connu} { return $L }
	if {$LoGlo=="Global" && $L==$Connu} { return $G }
    }
    return -1
}

proc CreeLeMSFduTFAs {FichierOuTexteTFAs FichierMSF} {
    return [ConvertToMsf $FichierOuTexteTFAs $FichierMSF]
} 

proc CreeLeTFAsDuMSF {FichierMSF {AvecGap ""} {SansVide ""}} {

    if {$AvecGap==""} { set AvecGap "AvecGap" }
    if {$SansVide==""} { set SansVide 0 } else { set SansVide 1 }

    set n [DecortiqueUnMSF $FichierMSF LesNomsDesSequencesDansLOrdre Sequences]

    if {$n<=0} { return {} }
    foreach NomDeSequence $LesNomsDesSequencesDansLOrdre {
	set Seq [set Sequences($NomDeSequence)]
	if {$AvecGap=="AvecGap"} {
	    regsub -all {\.} $Seq "-" Seq
	} else {
	    regsub -all {[\.\-]} $Seq "" Seq
	}
	if {$SansVide && $Seq==""} { continue }
	lappend LesTFAs [SequenceFormatTFA $Seq "$NomDeSequence" "protbrut"]
    }
    return [join $LesTFAs "\n"]
}
    
proc UneSequenceDuMSF {FichierMSF NomDeLaSequence {NoGap ""}} {
    if {[DecortiqueUnMSF $FichierMSF LesNomsDesSequencesDansLOrdre Sequences]==0} { return "" }
    if { ! [info exists Sequences($NomDeLaSequence)]} { return "" }
    set Seq $Sequences($NomDeLaSequence)
    if {[regexp -nocase "NoGap" $NoGap]} { regsub -all {[\.\-]} $Seq "" Seq }
    return $Seq
}

proc TestDecortiqueUnMSF FichierMSF {
    DecortiqueUnMSF $FichierMSF LesNoms Sequences
    foreach NomSeq $LesNoms {
	set Seq $Sequences($NomSeq)
	regsub -all {\.} $Seq "" Lettres
	Espionne "$NomSeq [string length $Seq] [string length $Lettres]"
	Espionne $Seq
    }
    exit
}

proc LesAccessDuMSF TexteOuFichierMSF {
    DecortiqueUnMSF $TexteOuFichierMSF LesAccess
    return $LesAccess
}

proc DecortiqueUnMSF {TexteOuFichierMSF {aLesNomsDesSequencesDansLOrdre ""} {aSequences ""} {OutType ""}} {
    #rR OutType peut etre ordali, msf, tfa, ou same. Dans ce cas on ne change pas la sequence 
    if {$aLesNomsDesSequencesDansLOrdre!="" } { upvar $aLesNomsDesSequencesDansLOrdre LesNomsDesSequencesDansLOrdre }
    if {$aSequences!=""} { upvar $aSequences Sequences }
 
    set LesNomsDesSequencesDansLOrdre {}

    if {[regexp "\n" $TexteOuFichierMSF]} {
	set LesLignes [split $TexteOuFichierMSF "\n"]
	set FichierMSF "MSF"
    } else {
	set FichierMSF $TexteOuFichierMSF
	if {[EstUnPAB $TexteOuFichierMSF]} { set FichierMSF [GscopeFile $FichierMSF "msf"] } 
	set LesLignes [LesLignesDuFichier $FichierMSF]
    }

    if {[llength $LesLignes] < 2} { return 0 }

    set iSlashSlash [expr [lsearch -regexp $LesLignes "//"]+1]
    
    #lm Traite le header du MSF pour recuperer la liste
    #lm des noms de sequence
    set iStart [lsearch -regexp $LesLignes {^MSF\:*\.\.}]
    foreach Ligne [lrange $LesLignes $iStart+1 $iSlashSlash-2] {
	set Ligne [string trim $Ligne]
	if {$Ligne eq ""} { continue }
	if {[string first "Name" $Ligne] == 0 && [string first "Weight" $Ligne] > 0} {
	    #lm ligne nom de sequence
	    regsub -all { +} $Ligne " " Ligne
	    
	    set NomSeqLu [lindex [split $Ligne " "] 1]
	    regsub {/.*} $NomSeqLu "" NomSeqLu
	    set NomSeqLu [string map [list | :] $NomSeqLu]
	    set NomSeq $NomSeqLu
	    set NomSeq [BonAccess $NomSeq]
	    lappend LesNomsDesSequencesDansLOrdre $NomSeq
	}
    }

    #lm Traite le corps du MSF 
    foreach Ligne [lrange $LesLignes $iSlashSlash end] {
	if { ! [regexp {[\.a-zA-Z]} $Ligne] } { continue }
	scan $Ligne "%s" NomSeqLu
	set iNomSeqLu [string first $NomSeqLu $Ligne]
	set NomSeqLu [string map [list | :] $NomSeqLu]
	set iBlanc [expr {$iNomSeqLu+[string length $NomSeqLu]}]
	regsub {/.*} $NomSeqLu "" NomSeqLu
	set NomSeq $NomSeqLu
	set NomSeq [BonAccess $NomSeq]

	set BoutSequence [string map [list " " ""] [string range $Ligne $iBlanc end]]
	set BoutSequence [BonneSequencePourAlignement $BoutSequence $OutType]
	if { ! [info exists DejaVu($NomSeq)]} {
	    #lm on tient compte des doublons
	    #lappend LesNomsDesSequencesDansLOrdre $NomSeq
	}
	if {$aSequences!=""} {
	    if { ! [info exists DejaVu($NomSeq)]} {
		set Sequences($NomSeq) $BoutSequence
 	    } else {
		append Sequences($NomSeq) $BoutSequence
	    }
	}
	set DejaVu($NomSeq) 1
    }
    return [llength $LesNomsDesSequencesDansLOrdre]
#rR le reste est obsolete
#    if {$aSequences!=""} {
#	set Lns [array get Sequences]
#	Log $Lns
#	unset LesNomsDesSequencesDansLOrdre
#	if {[info exists Sequences]} { unset Sequences }
#	foreach {n s} $Lns {
#	    set n [BonAccess $n]
#	    set s [BonneSequence $s]
#	    set Sequences($n) $s
#	}
#	set LesNomsDesSequencesDansLOrdre [array names Sequences]
#    }
#    return [llength $LesNomsDesSequencesDansLOrdre]
}

proc CorrectionPourVarsplicDuBlastPPourTous {} {
    foreach Nom [ListeDesPABs] {
	set Fichier "[RepertoireDuGenome]/blastp/$Nom"
	if { ! [file exists $Fichier]} { continue }
	regsub "/blastp/" $Fichier "/blastpOK/" Out
	Espionne [CorrectionPourVarsplicDuBlastP $Fichier $Out]
    }
    exit
}

proc CorrectionPourVarsplicDuBlastP {Fichier {Out ""}} {
    if {$Out==""} { set Out $Fichier }
    set nVus 0
    set LeNouveau {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if {[regexp -nocase {^VARSPLIC\:} $Ligne]} {
	    incr nVus
	    scan $Ligne "%s %s" BId Access
	    set BonAccess [StringApres ":" dans $BId]
	    if { ! [string equal -nocase $Access $BonAccess]} {
		set d [expr [string length $BonAccess] - [string length $Access]]
		if {$d<0} {
		    regsub " $Access" $Ligne " $BonAccess[string repeat " " [expr -$d]]"
		}
		if {$d==0} {
		    regsub " $Access" $Ligne " $BonAccess"
		}
		if {$d>0} {
		    regsub " $Access" $Ligne " $BonAccess" Ligne
		    set Ligne [string replace $Ligne [expr 66-$d+1] 66]
		}
		lappend LeNouveau $Ligne
		continue
	    }
	}
	if {[regexp -nocase {>VARSPLIC\:} $Ligne]} {
	    if {$nVus==0} { break }
	    scan $Ligne "%s %s" BId Access
	    set BonAccess [StringApres ":" dans $BId]
	    regsub " $Access" $Ligne " $BonAccess" Ligne
	    lappend LeNouveau $Ligne
	    continue	
	}
	lappend LeNouveau $Ligne
	continue
    }
    if {$nVus==0 && $Fichier==$Out} { return $Out }
    if {$nVus==0 && $Fichier!=$Out} { file copy -force $Fichier $Out ; return $Out }
    return [SauveLesLignes $LeNouveau dans $Out]
}

proc MsfLeon {Nom {Quoi ""}} {

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

    set FichierLeon "[RepertoireDuGenome]/msfleon/$Nom"
    if {$Quoi=="FileName"} { return $Fichier }
    if { ! [file exists $FichierLeon]} { return "" }
    if {$Quoi=="Text"}  { return [ContenuDuFichier $FichierLeon] }
    if {$Quoi=="Lines"} { return [LesLignesDuFichier $FichierLeon] }
    if {$Quoi=="NorMD"} {
	
    }
    
}

proc FromDbClustalToLeon Nom {
    set FichierDbClustal "[RepertoireDuGenome]/msfdbclustal/$Nom"
    set FichierRascal    "[RepertoireDuGenome]/msfrascal/$Nom"
    set FichierLeon      "[RepertoireDuGenome]/msfleon/$Nom"
    if {[]} {}
}

proc ConvertToOneHundredPourTous {{RepIn ""} {RepOut ""}} {
    if {$RepIn==""} {
	set RepIn "[RepertoireDuGenome]/msf"
    }
    if {$RepOut==""} {
	set RepOut "$RepIn.100"
	if { ! [file exists $RepOut]} { file mkdir $RepOut }
    }
    foreach Nom [ListeDesPABs] {
	set In  "$RepIn/$Nom"
	set Out "$RepOut/$Nom"
	Espionne "ConvertToOneHundred $In $Out"
	if { ! [file exists $In]} { continue }
	ConvertToOneHundred $In $Out
    }
}

proc ConvertToOneHundred {In Out} {
    if {[regexp "NoSequencesToAlign" [PremiereLigneDuFichier $In]]} {
	File copy -force $In $Out
	return $Out
    }
    set Tmp [TmpFile]
    set LeDebut {}
    set YADebut 0
    foreach Ligne [LesPremieresLignesDuFichier $In 10] {
	if {[regexp -nocase {Name *\: } $Ligne]} { break }
	set YADebut 1
	lappend LeDebut $Ligne
    }
    if {[catch {exec clustalw $In -convert -output=gscope -outfile=$Tmp} Message]} {
	Warne "Clustalw couldn't convert the msf to 100 : \n$Message"
	File copy -force $In $Out
	return $Out
    }
    set LeNouveau $LeDebut
    set OnAttendName 1
    foreach Ligne [LesLignesDuFichier $Tmp] {
	if {$YADebut && $OnAttendName && ! [regexp -nocase {Name *\: } $Ligne]} { continue }
	set OnAttendName 0
	lappend LeNouveau $Ligne
    }
    file delete -force $Tmp
    return [SauveLesLignes $LeNouveau dans $Out]
}

proc RascalPourTous {{NomATraiter ""}} {
    global RepertoireDuGenome
    set AvecPasTouche 1
    if {$NomATraiter == ""} {
	set Liste [ListeDesPABs]
    } elseif {[llength $NomATraiter]==1} {
	if {[EstUnPAB $NomATraiter]} { set AvecPasTouche 0 }
	set Liste [list $NomATraiter]
    } else {
	set Liste $NomATraiter
    }

    set Repertoire "$RepertoireDuGenome/msfrascal"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }

    set GardeTout 1
    set TestExistence 1
    while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
	if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
	    set TestExistence 1
	    set GardeTout 1
	    break 
	} elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
	    set TestExistence 0
	    set GardeTout 0
	    break
	} elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
	    set TestExistence 1
	    set GardeTout 0
	    break
	}
    }

    set LesCrees {}
    foreach Nom $Liste {
	if {$AvecPasTouche && [PasTouche $Nom]} { continue }
	set FichierMSF    "$RepertoireDuGenome/msf/$Nom"
	set FichierRascal "$Repertoire/$Nom"

	if { ! [file exists $FichierMSF]} { 
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue
	}
	if {$GardeTout && [file exists $FichierRascal] } {
	    Espionne "$Nom already done"
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue 
	}
	if { $TestExistence && [file exists $FichierRascal] } {
	    if {[OuiOuNon "$FichierRascal already exists\nDo I keep it ?"]} {
		if {$AvecPasTouche} { FinPasTouche $Nom }
		continue
	    }
	}

	set FichierCree [Rascal $FichierMSF $FichierRascal "Annotate" ]
	lappend LesCrees $FichierCree
	Espionne "Rascal created $FichierCree"

	if {$AvecPasTouche} { FinPasTouche $Nom }
    }
    return $LesCrees
}

proc Rascal {FichierOuNom {Destin ""} {Annotate "Annotate"}} {
    global RepertoireDuGenome

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

    set Nom [file tail $FichierOuNom]
    if { ! [regexp "/" $FichierOuNom]} { set FichierOuNom "$RepertoireDuGenome/msf/$Nom" }

    set FichierMSF $FichierOuNom

    if { ! [file exists $FichierOuNom]} { return "" }
    if {[regexp "NoSequence" [PremiereLigneDuFichier $FichierOuNom]]} { return "NoSequencesToAlign" }

    if {$Annotate} {
	set OldNorMD [MDScore $FichierMSF "CalculeMoi"]
    }
    if {[string equal -nocase $Destin "InRascalDir"]} {
	set RascalDir "$RepertoireDuGenome/msfrascal" 
	if { ! [file exists $RascalDir]} { File mkdir $RascalDir }
	set FichierRascal "$RascalDir/$Nom"
    } elseif { $Destin=="" } {
	set FichierRascal $FichierMSF
    } else {
	set FichierRascal $Destin
    }

    set TmpRascal "[TmpFile].rascal"
    if {[catch {exec rascal $FichierMSF $TmpRascal} Message]} {
	Warne "Error from rascal. Message follows \n$Message"
	return ""
    }
        if { ! [file exists $TmpRascal]} {
	Warne "Error from rascal. File not created"
	return ""
    }	

    global RascalConvertToOneHundred
    if { ! [info exists RascalConvertToOneHundred]} { set RascalConvertToOneHundred 1 }
    if {$RascalConvertToOneHundred} { ConvertToOneHundred $TmpRascal $TmpRascal }

    if {$Annotate} {
	set NewNorMD [MDScore $TmpRascal "CalculeMoi"]
	set LeRascal [LesLignesDuFichier $TmpRascal]
	set DeuxiemeLigne [string trimright [IemeLigneDuFichier $FichierMSF 2]]
	if {$OldNorMD<=$NewNorMD} {
	    set Changed "improved"
	} else {
	    set Changed "reduced"
	}
	append DeuxiemeLigne " Rascal $Changed NorMD from $OldNorMD to $NewNorMD"
	set LeRascal [linsert $LeRascal 1 $DeuxiemeLigne]
    }
    File delete -force $TmpRascal
    return [SauveLesLignes $LeRascal dans $FichierRascal]
}

proc Tdbc {} {
    global RepertoireDuGenome
    set LesAccess [LesLignesDuFichier "$RepertoireDuGenome/descriptifs/VCHO10004"]
    set Texte [join $LesAccess "\n"]
    DbClustal toto oscar.msf $Texte "AvecSelection"
    exit
}

proc TestGscopeCroises {} {
    EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP {} Court"]
    EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY1969 BlastP {} Court"]
    EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353333 BlastP {} Court"]
    EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2354 BlastP"]
    EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP"]
    EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP"]
}

proc LesAccessDuAliInOut {NomOuFichier {InOut "All"}} {
    global RepertoireDuGenome

    set Nom [file tail $NomOuFichier]
    set Fichier "$RepertoireDuGenome/aliinout/$Nom"
    if { ! [file exists Fichier]} { set Fichier $NomOuFichier }
    if { ! [file exists Fichier]} { return {} }
    
    set All [regexp -nocase "All" $InOut]
    set In  [regexp -nocase "In"  $InOut]
    set Out [regexp -nocase "Out" $InOut]
    set LesAccess {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s %s" BID Access
	if {[EstUnAccessPDB $BID]} { set Access $BID }
	if {$All} { lappend LesAccess $Access }
	if {$In  && [regexp "accepted" $Ligne]} { lappend LesAccess $Access }
	if {$Out && [regexp "rejected" $Ligne]} { lappend LesAccess $Access }
    }
    return $LesAccess
}

proc RapportAliInOut {Rapport Nom} {
    global SortieRapportAliInOut
    global SortieRapportAliInOutFichierMemo


    if { ! [info exists SortieRapportAliInOut]} {
	set Texte "$Nom $Rapport"
	Espionne $Texte
	return $Texte
    }
    set FichierSortie "$SortieRapportAliInOut/$Nom"
    if { ! [info exists SortieRapportAliInOutFichierMemo] \
	    || $FichierSortie!=$SortieRapportAliInOutFichierMemo} {
	if {[file exists $FichierSortie]} { File delete -force $FichierSortie }
    }
    set SortieRapportAliInOutFichierMemo $FichierSortie
    return [AppendAuFichier $FichierSortie $Rapport]
}

proc RacineDuPDB Access {
    regsub {_[A-Z]+$} $Access "" Racine
    return $Racine
}

proc EstUnFragment {BID {Access ""} {DE ""}} {
    if {$DE!=""} { return [regexp -nocase "FRAGMENT" $DE] }
    return 0
}

proc TailleDuDescriptifDuBlastP {{Ask ""}} {
    global RepertoireDuGenome
    global GscopeDir
    global TailleDuDescriptifDuBlastP

    set Ask [regexp -nocase "^Ask$" $Ask]

    if {! $Ask && [info exists TailleDuDescriptifDuBlastP]} {
	return $TailleDuDescriptifDuBlastP
    }

    set FichierTaille "$RepertoireDuGenome/fiches/sizedescriptif"
    if { $Ask || ! [file exists $FichierTaille]} {
	set FichierTailleDefaut "$GscopeDir/gscope_sizedescriptif"
	if {[file exists $FichierTailleDefaut] && \
		[OuiOuNon "Do I copy the file \n\
		$FichierTailleDefaut\n\
		to $FichierTaille\n ?"]} {
	    File copy $FichierTailleDefaut $FichierSortie
	} else {
	    while {[OuiOuNon "Do You want to load an existing file with sizes for description ?"]} {
		set F [ButineArborescence "All" $RepertoireDuGenome]
		if {$F==""} { continue }
		if {[OuiOuNon "Do I copy it to $FichierTaille ?"]} {
		    File copy -force $F $FichierTaille
		} else {
		    set FichierTaille $F
		}
		break
	    }
	}
    }
    
    if {[file exists $FichierTaille]} {
	set VT [ContenuDuFichier $FichierTaille]
    } else {    
	set VT "90 120 30 10.  respectively : at_least max_with_complete_genomes max_pdb expect"
	set Ask 1
    }
    while {$Ask && [OuiOuNon "Do You want to modify the sizes ?"]} {
	set NewVT [Entre $VT]
	if {$NewVT==""} { continue }
	set VT $NewVT
	if {[OuiOuNon "Do I save these values in $FichierTaille ?"]} {
	    Sauve $VT dans $FichierTaille
	}
    }
    set TailleDuDescriptifDuBlastP $VT
    return $VT
}

proc LesDescriptifsDuBlast {FichierOuNom {Source ""}} {
    #rR Petite remarque : LesDescriptifs c'est assez compliqué
    #rR  ça a l'air de tourner en rond ... car ici on crée les descritptifs même s'ils existent déjà
    #rR  en fait il ne le rajoute que s'il n'existe pas
    #rR  (StockeLeDescriptif est assez intelligent )

    global RepertoireDuGenome
    global SeuilExpectPourJulie

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

    set Nom [file tail $FichierOuNom]

    scan [TailleDuDescriptifDuBlastP] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect 

    set MaxADecortiquer [expr $MaxVoulus+$MaxPDB]

    if {[info exists SeuilExpectPourJulie]} {
	set SeuilExpect $SeuilExpectPourJulie
    }

    Wup "On ne veut plus voir le meme PAB .......... peut servir autrement ... "
    set LesIndesirables {}
    if {0 && [regsub "^ABY$" $Nom "PAB" Indesirable]} {
	lappend LesIndesirables $Indesirables
    }
    set LesCandidats {}
    if {$Source=="daedalus" || ($Source=="" &&\
	    [OuiOuNonMemo "Do I use Daedalushits to collect the candidates for DbClustal ?" 0])} {
	set Source "daedalushits"
	set Fichier "$RepertoireDuGenome/$Source/$Nom"
	while { ! [file exists $Fichier]} {
	    if {[OuiOuNon "May be you forgot to run DaedalusHitsDuBlastPPourTous.\n\
		    Do I run it now ... (it could take a while) ? "]} {
		DaedalusHitsDuBlastPPourTous "EnProcessExterne"
	    } else {
		if {[OuiOuNon "Do I return an empty list of orthologs for $Nom ?" 0]} { return {} }
		if {[OuiOuNon "Do I use the blastp file ?"]} {
		    return [LesDescriptifsDuBlast $FichierOuNom "blastp"]
		}
	    }	    
	}
	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"]
	    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 $OS $BeauDE $OC"
	    lappend LesCandidats $Candidat
	    regsub -all {\:} $DE "_" DE
	    set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX"
	    StockeLeDescriptif $AccessOK $Descriptif $Nom
	}
	Espionne "$Nom accepts [llength $LesCandidats] candidats"
	return $LesCandidats
    }
    if {[file exists $FichierOuNom] && $Nom!=$FichierOuNom} {
	set Fichier $FichierOuNom
    } else {
	set Fichier "$RepertoireDuGenome/$Source/$Nom"
    }
    if { ! [file exists $Fichier]} { return {} }
    
    DecortiqueBlast $Fichier $SeuilExpect $MaxADecortiquer Query lBanqueId lAccess lDE lProfil lPN

    #rR rajout 2014/11/25
    set LesBonBid {}
    set LesBonAcc {}
    foreach BID $lBanqueId ACC $lAccess {
	if {[regexp {\|} $BID]} {
	    lassign [split $BID "|"] Ban BonAcc BonBid
	    lappend LesBonAcc $BonAcc
	    lappend LesBonBid $BonBid
	    continue
	}
	lappend LesBonAcc $ACC
	lappend LesBonBid $BID
    }
    set lAccess   $LesBonAcc
    set lBanqueId $LesBonBid
    
    set NbEnMemoire [PrepareLesSequencesDesBanques $lBanqueId $lAccess "DefaultBlastPDatabase"]          ;#rR 20171031 rajout de DefaultBlastPDatabase
    Espionne "$NbEnMemoire/[llength $lBanqueId] EMBL mis en memoire par PrepareLesSequencesDesBanques"
    
    foreach BanqueId $lBanqueId Access $lAccess PetitDE $lDE Profil $lProfil PN $lPN {
	if {[lsearch -exact $LesIndesirables $Access] > 0 } { continue }

#	if {$FromDescriptifs} {
#	}
	    

	set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
	if {$LesLignesEMBL=={}} { continue }
	DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
	Espionne $DE
	if {$DE==""} { set DE $PetitDE }
	LeDescriptif $AC $Nom $DE         ;#rR rajout 2013/10/17 : Mise en memoire pour ConcatLeTFAs 
	regsub -all " " $DE "_" BeauDE
	lappend LesCandidats "$BanqueId $Access $PN $OS $BeauDE $OC"
	regsub -all {\:} $DE "_" DE
	set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX"
	StockeLeDescriptif $AccessOK $Descriptif $Nom
    }
    return $LesCandidats
}

proc TestCreeLaListeLesCopains {} {
}

proc CreeLaListeLesCopains {FichierOuNom {Source ""} {EvalCommand ""}} {
    global RepertoireDuGenome
    global NotreOS
    global DejaVuCeComplet
    global SeuilExpectPourJulie
    global LesOrganismesModelesAAligner
    global WithoutVarsplic
    global WithoutFragment
    global FirstPDBOnly
    if { ! [info exists WithoutVarsplic]} { set WithoutVarsplic 0 }
    if { ! [info exists WithoutFragment]} { set WithoutFragment 1 }
    if { ! [info exists FirstPDBOnly]   } { set FirstPDBOnly    1 }

    if {[OnTraiteMS2PH]} {
	set  WithoutFragment 0
	global TryGCG ; set TryGCG 0
    }

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

    Wup "Creates the list of best orthologs in blastp or ballast" 

    set Nom [file tail $FichierOuNom]

    set LesOrganismesFamiliers  [FamiliarOrganism "LaListeMerci"]
    set LesOrganismesImportants [LesOrganismesImportantsPourDBClustal]
    scan [TailleSortiePourDBClustal] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect 

    if { ! [info exists DejaVuCeComplet]} {
	foreach Ligne $LesOrganismesImportants {
	    if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	    set Genre ""
	    set Espece ""
	    scan $Ligne "%s %s" Genre Espece
	    set Complet "$Genre $Espece"
	    set Orga [Glossaire $Complet Complet]
	    set DejaVuCeComplet([string toupper $Orga]) 0
	}
    }
    foreach Genome [array names DejaVuCeComplet] {
	set DejaVuCeComplet($Genome) 0
    }
    set nPDB 0
    set nCops 0
    set ncomplets 0
    set LesCopains {}
    set LesCandidatsPotentiels [LesDescriptifsDuBlast $FichierOuNom $Source]
    foreach Candidat $LesCandidatsPotentiels {
	if { $nCops >= $MaxVoulus} {
	    RapportAliInOut "$BanqueId $Access break : ncops $nCops >= $MaxVoulus" $Nom
	    break
	}
	set Genre "Unknown unknown"
	set Espece ""
	set DE ""
	scan $Candidat "%s %s %f %s %s %s" BanqueId Access PN Genre Espece DE
	regsub -all "_" $DE " " DE

	if {$EvalCommand!=""} {
	    set R [EvalCom $EvalCommand $Candidat]
	    if {[regexp -nocase "^Reject" $R]} {
		RapportAliInOut "$BanqueId $Access rejected by evalcom : $R" $Nom
		continue
	    }
	}

	if { $Source != "ballast" && $PN > $SeuilExpect } {
	    RapportAliInOut "$BanqueId $Access break : expect $PN > $SeuilExpect" $Nom
	    break
	}

	if {$WithoutVarsplic && [regexp -nocase "^VARSPLIC" $BanqueId]} {
	    RapportAliInOut "$BanqueId $Access rejected, VARSPLIC : $DE" $Nom
	    continue
	}

	if {$WithoutFragment && [EstUnFragment $BanqueId $Access $DE]} {
	    RapportAliInOut "$BanqueId $Access rejected, fragment : $DE" $Nom
	    continue
	}

	if {[EstUnAccessPDB $BanqueId]} {
	    set Racine [RacineDuPDB $BanqueId]
	    if {$FirstPDBOnly} {
		if {[info exists DejaVuCePDB($Racine)]} {
		    RapportAliInOut "$BanqueId $Access rejected, other PDB already taken [set DejaVuCePDB($Racine)]." $Nom
		    continue
		}
		set DejaVuCePDB($Racine) $BanqueId
	    }
	    if {[incr nPDB]>$MaxPDB} {
		RapportAliInOut "$BanqueId $Access rejected, more than $MaxPDB PDB." $Nom
		continue
	    }
	    set Orga [OrganismeDuPDB $BanqueId]
	    lappend LesCopains "$BanqueId $Access $PN $Orga"
	    RapportAliInOut "$BanqueId $Access $Orga accepted after $nCops th, PDB $nPDB" $Nom
	    continue
	}

	set OS "$Genre $Espece"
	set Orga [OrganismeCanonique $OS "NonStricte"]
	if {$Orga==""} {
	    if {[OuiOuNon "I skip $OS"]} {
		RapportAliInOut "$BanqueId $Access rejected : $Organisme unknown >$OS<" $Nom
		continue
	    }
	    set Orga $OS
	}
	Wup "Si on ne veut qu'une seule fois chaque complet mettre 1"
	set UneSeuleFoisLesComplets [OuiOuNonMemo "Do I use only one time each organism" 0]
	if {$UneSeuleFoisLesComplets && [info exists DejaVuCeComplet([string toupper $Orga])]} {
	    if { $nCops >= $MinObliges && [set DejaVuCeComplet([string toupper $Orga])]} {
		RapportAliInOut "$BanqueId $Access rejected : $Orga already seen." $Nom
		continue 
	    }
	} else {
	    if { $nCops >= $MinObliges && \
		    ! [info exists DejaVuCeComplet([string toupper $Orga])] } {
		RapportAliInOut "$BanqueId $Access rejected : $Orga $nCops >= $MinObliges" $Nom
		continue 
	    }
	}
	if {[info exists DejaVuCeComplet([string toupper $Orga])]} {
	    set DejaVuCeComplet([string toupper $Orga]) 1
	}
	incr nCops
	RapportAliInOut "$BanqueId $Access $Orga accepted as $nCops th." $Nom
	lappend LesCopains "$BanqueId $Access $PN $Orga"
    }
    return $LesCopains
}

proc TFAsDuBlast {Fichier {Organisme ""} {SeuilExpect ""} {MaxSeq ""} {WithBId ""} {AlreadyTFA ""}} {

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

    set WithBId [string equal -nocase $WithBId "WithBId"]
    set AlreadyTFA [string equal -nocase $AlreadyTFA "AlreadyTFA"]

    if {$Organisme!=""} { set Organisme [Glossaire $Organisme Complet] }

    DecortiqueBlast $Fichier \
	    $SeuilExpect $MaxSeq Query lBanqueId lAccess lDE lProfil lPN
    PrepareLesSequencesDesBanques $lBanqueId $lAccess
    
    set OnVeutQuoi "OnVeutEMBL"
    if {$AlreadyTFA} { set OnVeutQuoi "OnVeutNature" }

    set LesTFAs {}
    foreach BanqueId $lBanqueId Access $lAccess Profil $lProfil PN $lPN {
	set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK $OnVeutQuoi]
	if { ! $AlreadyTFA} {
	    DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
	    if {$Organisme!="" && $OS!=$Organisme} { continue }
	    regsub -all {\:} $DE "_" DE
	    set Format "embl"
	    if {[regexp -nocase {^REFSEQ:} $BanqueId]} { set Format "tfa" }
	    set BouA $AC
	    if {$WithBId} { set BouA $BanqueId }
	    set TFA [SequenceFormatTFA_l $LesLignesEMBL "$BouA $OS $DE" $Format]
	} else {
	    set TFA [join $LesLignesEMBL "\n"]
	}
	lappend LesTFAs $TFA
#	lappend LesCandidats "$BanqueId $Access $PN $OS $OC"	
    }
    return [join $LesTFAs "\n"]
#    return $LesCandidats
}

proc OnAligneTousLesElusDuBlastPPar {Methode {Value ""}} {
    #rR Attention toutes les méthodes sont exclusives ... on ne peut en faire qu'une seule
    global OnAligneTousLesElusDuBlastPPar
    if {$Value!=""} {
	if {[info exists OnAligneTousLesElusDuBlastPPar]} { unset OnAligneTousLesElusDuBlastPPar }
	set OnAligneTousLesElusDuBlastPPar($Methode) $Value
    }
    if {[info exists OnAligneTousLesElusDuBlastPPar($Methode)]} { return $OnAligneTousLesElusDuBlastPPar($Methode) }
    return 0
}

proc DbClustalPourTous {{NomATraiter ""} {Source ""} {ChangeQuery ""}} {
    global RepertoireDuGenome
    global LesOrganismesModelesAAligner
    global OptionsBallastPourJulie SeuilExpectPourJulie
    global OptionsBallastPourJulieDemande
    global SortieRapportAliInOut
    global NotreOS
    global OnEffaceBallast
    global OkPourTfaDesCopains ;#rR 2015/01/19  mis en debut et lu aussi dans source 

    if {[string equal -nocase "All" $NomATraiter]} { set NomATraiter "" } ;#rR pour eviter le "" en ligne de commande

    set QueryForAnchors ""

    set SourceOrigine $Source

    set ForceTFAsDesCopains 0
    if {[regexp -nocase "TFAsDesCopains" $Source]} {
	set OkPourTfaDesCopains 1
	set ForceTFAsDesCopains 1
    }

    if {[string equal -nocase $NomATraiter "All"]} { set NomATraiter "" }

    if {[OnTraite "Ribosome"]} {
	UseBanqueIdForDbClustal 1
	set SeuilExpectPourJulie 10.	
    }

    if {[regexp -nocase "Bandelettes" $Source]} {
	OnAligneTousLesElusDuBlastPPar "Bandelettes" 1
	set OptionsBallastPourJulie "-dbclustal 0.000000"
	set SeuilExpectPourJulie 10.
	if {[OnTraiteMS2PH]} { set SeuilExpectPourJulie 0.001 }
	set OptionsBallastPourJulieDemande 1
	OnVireLesMonstresLointains 1
    }

    if {[regexp -nocase "Mounir" $Source]} {
	OnAligneTousLesElusDuBlastPPar "Mounir" 1
	set OptionsBallastPourJulie "-dbclustal 0.000000"
	set SeuilExpectPourJulie 0.001
	set OptionsBallastPourJulieDemande 1
	OnVireLesMonstresLointains 1
    }

    if {[regexp -nocase "AuChoix" $Source]} {
	OnAligneTousLesElusDuBlastPPar "AuChoix" 1
	set OptionsBallastPourJulie "-dbclustal 0.000000"
	set SeuilExpectPourJulie 0.001
	set OptionsBallastPourJulieDemande 1
	OnVireLesMonstresLointains 1
    }
    #rR 2014/07/01  rajout de OrthologsFromOrthoInspector
    #rR             ne marche que pour CilioCarta pour le moment ... voir ci-dessous Source



    #rR Et EvalCommand ... ne marche pas encore .............. à développer :
    #rR    En fait j'imagine une commande qui rejette chaque access du blast
    #rR Le tout est de savoir où le placer ... avant, pendant ou après LaSelectionUnique
    set EvalCommand 0
    if {[regexp "^eval_" $Source]} {
	set EvalCommand 1
	regsub "^eval_" $Source "" Commande
	regsub -all "_" $Commande " "
    }

    set OnEffaceBallast 0

    set AvecPasTouche 1
    set Liste {}
    if {$NomATraiter == "" } { 	
	set Liste [ListeDesPABs]
    } elseif {$NomATraiter=="ListeDesFusions"} {
	set Liste [ListeDesFusions]
    } elseif {[EstUnPAB $NomATraiter]} {
	set Liste [list $NomATraiter]
	set AvecPasTouche 0
    } elseif {[llength $NomATraiter] > 1} {
	set Liste $NomATraiter
    } elseif {[file exists $NomATraiter]} {
	set Liste [LesLignesDuFichier $NomATraiter]
    } elseif {$NomATraiter=="PourJulie"} {
	set Liste [LesLignesDuFichier "[RepertoireDuGenome]/fiches/liste_pour_julie"]
    }

    if { ! [info exists SortieRapportAliInOut]} {
	set SortieRapportAliInOut "$RepertoireDuGenome/aliinout"
	if { ! [file exists $SortieRapportAliInOut]} {
	    File mkdir $SortieRapportAliInOut
	}
    }

    if {[OnTraite "PubSpine"]} {
	set OptionsBallastPourJulieDemande 1
	set OptionsBallastPourJulie "-dbclustal 0.00000"
	set SeuilExpectPourJulie 10
    }
    if { ! [info exists OptionsBallastPourJulieDemande] \
	    && [OuiOuNon "Do You want to change ballast options and expect ?" 0]} {
#	set OptionsBallastPourJulie [Entre "-dbclustal 0.000001"]
	set OptionsBallastPourJulie [Entre "-dbclustal 0.000000"]
	set SeuilExpectPourJulie [Entre 10.]
    }
    set OptionsBallastPourJulieDemande 1

    set RepertoireMSF "$RepertoireDuGenome/msf"
    if { ! [file exists $RepertoireMSF]} { File mkdir $RepertoireMSF }

    set RepertoireTfasDesCopains "$RepertoireDuGenome/tfasdescopains"
    if { ! [file exists $RepertoireTfasDesCopains]} { File mkdir $RepertoireTfasDesCopains }

    if {$NomATraiter==""} {
	set LesQuels "*"
    } else {
	set LesQuels [file tail $NomATraiter]
    }
    set Conserve 0
    if {[llength [glob -nocomplain "$RepertoireMSF/$LesQuels"]] > 0} {
	set Conserve [OuiOuNon "Should I keep the existing files in $RepertoireMSF"]
    }

    set UseBirdFromTheBlast 0
    set Status "NothingHappend"
    foreach Nom $Liste {
	if {[Fantome $Nom]} { continue } 

	set FichierMSF "$RepertoireMSF/$Nom"
	if {$Conserve && [file exists $FichierMSF] } { continue }
	if {$AvecPasTouche && [PasTouche $Nom]} { continue }

	Espionne "Je vais preparer $Nom pour DbClustal"

	set FichInTFAs "$RepertoireTfasDesCopains/$Nom"
	if { ! [info exists OkPourTfaDesCopains]} {
	    set OkPourTfaDesCopains [OuiOuNon "Can I use the existing files $FichInTFAs" 0]
	}
	if {$ForceTFAsDesCopains && ! [file exists $FichInTFAs]} {
	    Sauve "NoSequencesToAlign" dans $FichierMSF
	    Warne "$Nom fichier tfasdescopains is empty !!!!"
	    FinPasTouche $Nom
	    continue
	} elseif {$OkPourTfaDesCopains && [file exists $FichInTFAs]} {
	    set Source $FichInTFAs
	    set AvecQuoi "AvecFichierTFAs"
	    if {[regexp -nocase "First" $ChangeQuery]} {
		Espionne $FichInTFAs [PremiereLigneDuFichier $FichInTFAs]
		regexp {^>([^ ]+) *$} [PremiereLigneDuFichier $FichInTFAs] Match QueryForAnchors
		Espionne QueryForAnchors $QueryForAnchors
	    }
	} else {
	    set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"
	    Espionne $FichierBlastP
	    BirdFromTheBlast $FichierBlastP  
	    
	    if { ! [file exists $FichierBlastP]} {
		Warne "$Nom pas de fichier blastp"
		FinPasTouche $Nom
		continue		
	    }
	    if {[OnAligneTousLesElusDuBlastPPar "Tous"]} {
		#rR il me semble qu'on ne passe jamais par là !!!!!!!!!!!!!!!
		set lBanqueId {}
		set lAccess   {}
		set lPN       {}
		
		DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" Query \
		    lBanqueId lAccess lDE lProfil lPN
		set O ""
		set LaSelectionUnique {}
		foreach B $lBanqueId A $lAccess E $lPN {
		    #rR rajouté 2014/11/25 ************************************************************
		    if {[regexp "\|" $B]} {
			set A [lindex [split $B "|"] 1]
			set B [lindex [split $B "|"] 2]
		    }
		    lappend LaSelectionUnique "$B $A $E $O" 
		}
	    } elseif { [OnAligneTousLesElusDuBlastPPar "Bandelettes"] } {
		set LaSelectionUnique [LesElusDuBlastPParBandelettes $Nom "blastp"]
	    } elseif { [OnAligneTousLesElusDuBlastPPar "Mounir"]} {
		set LaSelectionUnique [LesElusDuBlastPParMounir $Nom "blastp"]
	    } elseif { [OnAligneTousLesElusDuBlastPPar "AuChoix"] } {
		set LaSelectionUnique [LesElusDuBlastPParAuChoix $Nom "blastp"]
	    } elseif {[regexp -nocase "Ortholog" $SourceOrigine]} {
		set LaSelectionUnique [OiOrthologsFromCilioCarta $Nom "IDs"]
	    } else {
		set LaSelectionUnique [CreeLaListeLesCopains $FichierBlastP "blastp"]
	    }
	    
#	    BirdFromTheBlast "Reset"  

	    if {[llength $LaSelectionUnique] == 0} {
		Warne "$Nom pas de sequences a aligner"
		Sauve "NoSequencesToAlign" dans $FichierMSF
		FinPasTouche $Nom
		continue
	    }

	    set FichierQuery "$RepertoireDuGenome/prottfa/$Nom"
	    if { ! [file exists $FichierQuery]} {
		set FichierQuery "$RepertoireDuGenome/protembl/$Nom"
	    }
	    if { ! [file exists $FichierQuery]} {
		Warne "$Nom pas de fichier prottfa ni protembl"
		FinPasTouche $Nom
		continue		
	    }		
	    set Selection "$FichierQuery $Nom 0.0 $NotreOS\n"
	    append Selection [join $LaSelectionUnique "\n"]
	    set Source $Selection
	    set AvecQuoi "AvecSelection"
	}
	Espionne $Source
	set Status [DbClustal $Nom $FichierMSF $Source $AvecQuoi "" "" "" $QueryForAnchors]

	if {[regexp "^NoSeq" $Status] || [regexp "PasDeSeq" $Status]} {
	    Sauve "NoSequencesToAlign" dans $FichierMSF
	}
	
	if {$Status=="OK"} {
	    if {$OnEffaceBallast} {
		set FichierBallast "$RepertoireDuGenome/ballast/$Nom"
		if {[file exists $FichierBallast]} { File delete -force $FichierBallast }
		foreach FichierBallastExt [glob -nocomplain "$FichierBallast.*"] { 
		    File delete -force $FichierBallastExt
		}
	    }
	}
	FinPasTouche $Nom
    }
    return $Status
}

proc DbClustal {Nom FichierMSF {Source ""} {AvecQuoi ""} {KeepInTFAs ""} {KeepAnchors ""} {KeepLog ""} {Query ""}} {
    global RepertoireDuGenome
    global Commandes
    global RepertoireDeTravail
    global MyDbClustal

    JeMeSignale

    Wup "AvecQuoi tells what is source. It can be AvecSelection AvecFichierTFAs AvecTexteTFAs"
    Wup "Each Keep... can be a file name or 'Keep' so it will not be deleted"

    if { ! [regexp "^/" $FichierMSF]} { set FichierMSF "[pwd]/$FichierMSF" }

    if {$AvecQuoi==""} { set AvecQuoi "AvecSelection" }

    if {$KeepInTFAs==""} {
	set KeepInTFAs 0
	set FichInTFAs ""
    } else {
	if {[regexp "^Keep" $KeepInTFAs]} {
	    set FichInTFAs ""
	} else {
	    set FichInTFAs $KeepInTFAs
	}	    
	set KeepInTFAs 1
    }

    if {$KeepAnchors==""} {
	set KeepAnchors 0
	set FichAnchors ""
    } else {
	if {[regexp "^Keep" $KeepAnchors]} {
	    set FichAnchors ""
	} else {
	    set FichAnchors $KeepAnchors
	}	    
	set KeepAnchors 1
    }

    if {$KeepLog==""} {
	set KeepLog 0
	set FichLog ""
    } else {
	if {[regexp "^Keep" $KeepLog]} {
	    set FichLog ""
	} else {
	    set FichLog $KeepLog
	}	    
	set KeepLog 1
    }

    set CommandeDbClustal [set Commandes(dbclustal)]
    if {[info exists MyDbClustal] && [info exists Commandes($MyDbClustal)]} {
	set CommandeDbClustal [set Commandes($MyDbClustal)]
    }

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

    set Racine [TmpFile $Nom]

    if {$FichInTFAs==""} {
	if {[EstUnPAB $Nom]} {
	    set FichInTFAs "$RepertoireDuGenome/tfasdescopains/$Nom"
	} else {
	    set FichInTFAs "$Racine.inp"
	}
    }

    set ButNo ""
    if {[regexp "penelope" $RepertoireDuGenome]} {
	regsub "^ABY" $Nom "PAB" PAB
	if {[regexp "^PAB" $PAB]} { set ButNo $PAB }
    }

    if {[regexp "AvecSelection" $AvecQuoi]} {
	set TexteTFA [ConcatLesTFAs $Source "ButNo:$ButNo"]
	Sauve $TexteTFA dans $FichInTFAs
    }
    if {[regexp "AvecFichierTFA" $AvecQuoi]} {
	set TexteTFA [ContenuDuFichier $Source]
	if {$Source!=$FichInTFAs} { Sauve $TexteTFA dans $FichInTFAs }
    }
    if {[regexp "AvecTexteTFA" $AvecQuoi]} {
	set TexteTFA $Source
	Sauve $TexteTFA dans $FichInTFAs
    }

    if {[regexp -all ">" $TexteTFA] < 2} {
	Warne "      ... !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! NoSequencesToAlign"
	return "NoSequencesToAlign"
    }

    NousAllonsAuBoulot
    set Anchors [FichierAnchorsPour $Nom]
    if { ! [file exists $Anchors]} {
	Warne "$Anchors\nfile not found, I run dbclustal without anchors"
	set Anchors "" 
    }
    set Anchors [AnchorsCoherents $FichInTFAs $Anchors $Nom $Query] 
    set In  "$Racine.inp"
    set Out "$Racine.out"
    set Log "$Racine.log"
    
    File copy -force $FichInTFAs $In

    Warne "$CommandeDbClustal\n $In\n $Out\n $Log\n $Anchors"
    Warne "                     pour $Nom lance en interactif ... un peu de patience. Merci."
    if {[catch { eval exec "$CommandeDbClustal $In $Out $Log $Anchors"} Message]} {
	set Lolo "I got an error during DbClustal $Nom with following message\n$Message"
	Warne $Lolo
	AppendAuFichier $Log $Lolo
	set Status "YaLog"
    }
    if { ! [file exists "$Out.msf"]} {
	Warne [ContenuDuFichier $Log]
	File copy -force $Log "$Out.log"
	set Status "YaLog"
    } else {
	File rename -force $Out.msf $FichierMSF

	if { ! $KeepInTFAs } { File delete -force $In }
	if { ! $KeepAnchors} { File delete -force $Anchors }
	if { ! $KeepLog    } { File delete -force $Log }
	set Status "OK"
    }
    if {$KeepInTFAs  && $FichInTFAs!=""  && [file exists $In]}      { File copy -force $In $FichInTFAs }
    if {$KeepAnchors && $FichAnchors!="" && [file exists $Anchors]} { File copy -force $Anchors $FichAnchors }
    if {$KeepLog     && $FichLog!=""     && [file exists $Log]}     { File copy -force $Log $FichLog }
    
    Warne "                                                            ... j'ai fini. $Status"
    OnRevientDuBoulot
    return $Status
}

proc DbClustalEtMacsims {FichierTfa {FichierMsf ""} {FichierXml ""} {FichierRsf ""} {FichierLog ""} {Delete ""}} {
    if { ! [regexp "^/" $FichierTfa]} { set FichierTfa "[pwd]/$FichierTfa" }
    regsub ".tfa$" $FichierTfa "" Racine
    if {$FichierMsf==""} { set FichierMsf "$Racine.msf" }
    if {$FichierXml==""} { set FichierXml "$Racine.xml" }
    if {$FichierRsf==""} { set FichierRsf "$Racine.rsf" }
    if {$FichierLog==""} { set FichierLog "$Racine.log" }
    if {[catch {set Status [DbClustal $Racine $FichierMsf $FichierTfa AvecFichierTFAs KeepInTFAs "" $FichierLog]} Message]} {
	return "Error. Something went wrong during DbClustal. I got  the message :\n$Message"
    }
    set LogDbClustal [ContenuDuFichier $FichierLog]
    if {$Status!="OK"} { return "Error. I could'nt get the alignment" } 
    if {[catch {set Status [Macsims $FichierMsf $FichierXml $FichierRsf $FichierLog]} Message]} {
	return "Error. Something went wrong during Macsims. I got  the message :\n$Message"
    }
    Sauve "$LogDbClustal\n[ContenuDuFichier $FichierLog]" dans $FichierLog
    foreach Mot [split $Delete "_"] {
	set F "Fichier$Mot"
	if {[regexp {\.$} $F]} {
	    set FSansPoint [string trimright $F "."]
	    if { ! [info exists $FSansPoint]} { continue }
	    foreach FF [glob -nocomplain "[set $FSansPoint].*"] {
		file delete $FF
	    }
	} else {
	    if { ! [info exists $F]} { continue }
	    foreach FF [glob -nocomplain "[set $F]*"] {
		file delete $FF
	    }
	}
    }
    return $Status
}

proc Alignons {PourQui {NomATraiter ""}} {
    global RepertoireDuGenome
    global ListeDesPABs
    global NotreOS

    set OnEffaceBallast 0

    if {$NomATraiter == "" } { 	
	set Liste [ListeDesPABs]
    } else {
	set Liste [list $NomATraiter]
    }

    if {$PourQui=="Paralogues"} {
	set RepertoireMSF "$RepertoireDuGenome/msfparalogues"
	File mkdir $RepertoireMSF
    }
    
    set Conserve 1
    if {[llength [glob -nocomplain "$RepertoireMSF/*"]] > 0} {
	set Conserve [OuiOuNon "Should I keep the existing files in $RepertoireMSF"]
    }

    foreach Nom $Liste {

	Espionne "Je vais traiter $Nom"

	set FichierMSF     "$RepertoireMSF/$Nom"
	set FichierBlastP  "$RepertoireDuGenome/blastp/$Nom"

	if {$PourQui=="Paralogues" && [ParaloguesDe $Nom]=={}} { continue }
	if { ! [file exists $FichierBlastP]} { continue }
	if { $Conserve && [file exists $FichierMSF] } { continue }
	
	if {[file exists "$RepertoireDuGenome/ballast/$Nom"]} {
	    set FichierBallast "$RepertoireDuGenome/ballast/$Nom" 
	} else { 
	    set FichierBallast [Ballast $FichierBlastP]
	}
	if {$FichierBallast != "" && \
		[regexp -nocase "fatal error" [join [LesPremieresLignesDuFichier $FichierBallast 10]] "\n"]} {
	    set FichierBallast ""
	}
	if {$PourQui=="Paralogues"} {
	    set LaSelectionUnique [ParaloguesDe $Nom "apn"]
	    EspionneL $LaSelectionUnique
	    Espionne [llength $LaSelectionUnique]
	    if {[llength $LaSelectionUnique] == 0} {
		continue
	    }
	} else {
	    set LaSelectionUnique [CreeLaListeLesCopains $FichierBlastP "blastp"]
	    if {[llength $LaSelectionUnique] == 0} {
		Warne "$Nom pas de sequences a aligner"
		Sauve "NoSequencesToAlign" dans $FichierMSF
		continue
	    }
	}

	set Selection "$RepertoireDuGenome/protembl/$Nom $Nom 0.0 $NotreOS\n"
	append Selection [join $LaSelectionUnique "\n"]

	set StatusDbClustal [DbClustal $Nom $FichierMSF $Selection "AvecSelection"]
	if {$OnEffaceBallast && [file exists $FichierBallast]} {
	    File delete -force $FichierBallast
	    foreach FichierBallastExt [glob -nocomplain "$FichierBallast.*"] { 
		File delete -force $FichierBallastExt
	    }
	}

	if {$StatusDbClustal=="OK"} { continue }
	if {$StatusDbClustal=="PasDeSequencesAAligner"} {
	    Warne "$Nom pas de sequences a aligner ou erreur dans l'alignement."
	    Sauve "NoSequencesToAlignOrError" dans $FichierMSF
	    continue
	}
	if {$StatusDbClustal=="YaLog"} {
	    continue
	}
    }    
}

proc RunDbClustal {Selection {NomOuFichierBlastP ""} {QuoiFaire ""}} {
JeMeSignale
    global RepertoireDuGenome
    global Commandes

    Wup "Runs DbClustal on Selection (if wanted with the anchors of the blastpfile NomOuFichierBlastP)"

    if {$QuoiFaire==""} { set QuoiFaire "ShowMsf" }

    if { ! [regexp "\n" $Selection] && ! [regexp " " $Selection] && [regexp "/" $Selection]} { 
	set Selection [ContenuDuFichier $Selection]
    }

    if {[regexp "Query=" $Selection]} {
	set Query [StringApres "Query=" dans $Selection]
    } else {
	set Query ""
    }

    set Nom "?"
    set WithAnchors 0
    if {$NomOuFichierBlastP!=""} {
	set Nom [file tail $NomOuFichierBlastP]	
	set FichierBlastP $NomOuFichierBlastP
	if { ! [file exists $FichierBlastP]} { set FichierBlastP "$RepertoireDuGenome/blastp/$Nom" }
	if {[EstUnFichierBlastP $FichierBlastP]} {
	    set WithAnchors 1
	}
	if { ! [regexp "^/" $FichierBlastP]} {
	    set FichierBlastP "[pwd]/$FichierBlastP"
	}
    } else {
	set FichierBlastP ""
    }

    NousAllonsAuBoulot
    set Racine [TmpFile]

    set Anchors ""
    if {$WithAnchors} {
	set RepBallast "$Racine.ballast"
	File mkdir $RepBallast
	set FichierBallast [Ballast $FichierBlastP $RepBallast $Query]
	if {$FichierBallast != "" && \
		[regexp -nocase "fatal error" [join [LesPremieresLignesDuFichier $FichierBallast 10]] "\n"]} {
	    set FichierBallast ""
	}
	set Anchors "$FichierBallast.anchors"
	if { ! [file exists $Anchors]} {
	    Warne "$Anchors\nfile not found, I run dbclustal without anchors"
	    set Anchors "" 
	}
    }
    set In  "$Racine.inp"
    set Out "$Racine.out"
    set Log "$Racine.log"
    if {$Anchors!=""} {
	set Anc "$Racine.anchors"
	File copy $Anchors $Anc
    } else {
	set Anc ""
    }

    if {[regexp "^>" $Selection]} {
	set TFAaAligner $Selection
    } else {
	set TFAaAligner [ConcatLesTFAs $Selection]
    }

    Sauve $TFAaAligner dans $In

    if {$Anc!=""} {
	set Anc [AnchorsCoherents $In $Anc $FichierBlastP]
    }
    if {[regexp -nocase "Get" $QuoiFaire]} { set Mode "Interactif" } else { set Mode "Batch" }
    if {$Mode=="Batch"} {
	catch {set Canal [open "| [set Commandes(dbclustal)] $In $Out $Log $Anc"]} Message
	fconfigure $Canal -blocking false -buffering line
	fileevent $Canal readable "ClosCanalEtMontreMSF dbclustal $Canal $Out.msf $Log"
	Warne "dbclustal est lance en batch"
	OnRevientDuBoulot
	return "$Out.msf"
    }
    Warne "DbClustal sur $Nom lance en interactif ... un peu de patience. Merci."
    eval exec "[set Commandes(dbclustal)] $In $Out $Log $Anc"
    Warne "                                                            ... j'ai fini."
    if { ! [file exists "$Out.msf"]} {
	if {$QuoiFaire=="GetMsfText" || $QuoiFaire=="GetMsfFilename"} { return "" }
	set Fenetre [AfficheVariable [ContenuDuFichier $Log] "AvecRien" $Log]
    } else {
	if {$QuoiFaire=="GetMsfText"} {
	    return [ContenuDuFichier $Out.msf]
	}
	if {$QuoiFaire=="GetMsfFilename"} {
	    return $Out.msf
	}
	set Fenetre [AfficheVariable [ContenuDuFichier $Out.msf] "AvecEtudeMSFGrandeLargeur" $Out.msf ]
    }

    foreach Fichier [glob -nocomplain "$Racine.*"] {
	if {$Fichier=="$Out.msf"} { continue }
	if {$Fichier=="$Anc"}     { continue }
#	File delete -force $Fichier
    }
    OnRevientDuBoulot
    return $Fenetre
}

proc TestAnchorsCoherents {} {
    global RepertoireDuGenome
    set FichierTFA     "$RepertoireDuGenome/tfasdescopains/PDB66"
    set FichierAnchors "$RepertoireDuGenome/ballast/PDB66.anchors"
    set FichierBlast   "$RepertoireDuGenome/blastp/PDB66"
    Espionne [AnchorsCoherents $FichierTFA $FichierAnchors $FichierBlast]
    exit
}

proc AnchorsCoherents {FichierTFA FichierAnchors NomOuFichierBlast {Query ""}} {
    global RepertoireDuGenome

    JeMeSignale

    Wup "If the names in the TFA and Anchors don't correspond I change in the TFA"
    Wup " in Ballast I do otherwize and change in the Anchor file."

    if { ! [regexp -nocase {[0-9a-z_]} $FichierAnchors]} { return "" }

    foreach Ligne [LesLignesDuFichier $FichierTFA] {
	if { ! [regexp "^>" $Ligne]} { continue }
	regsub ">" $Ligne "" Ligne
	scan $Ligne "%s" AccessTFA
	set ACCESSTFA [string toupper $AccessTFA]
	set EstDansTFA($ACCESSTFA) 1
	set Beau($ACCESSTFA) $AccessTFA
    }

    set ChangeQuery 0

    set LesAnchorsAChanger {}
    foreach Ligne [LesLignesDuFichier $FichierAnchors] {
	if { ! [regexp "^seq\:" $Ligne]} { continue }
	set AccessAnchor ""
	scan $Ligne "%s %s %s" Seq QueryLue AccessAnchor
	if {$Query!="" && $QueryLue!=$Query} { set ChangeQuery 1; set BETTERQUERY($QueryLue) $Query }
	set ACCESSANCHOR [string toupper $AccessAnchor]
	if {[info exists EstDansTFA($ACCESSANCHOR)]} { continue }
	set MauvaisAnchors($ACCESSANCHOR) 1
	lappend LesAnchorsAChanger $AccessAnchor
    }    
    if {$LesAnchorsAChanger=={} && ! $ChangeQuery} { return $FichierAnchors }

    set FichierBlast $NomOuFichierBlast
    if { ! [regexp "/" $NomOuFichierBlast] || ! [file exists $FichierBlast]} {
	set Nom $NomOuFichierBlast
	set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
    }
    if { ! [file exists $FichierBlast]} { return $FichierAnchors }

    DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
    foreach BanqueId $lBanqueId Access $lAccess {
	regsub {\:} $BanqueId "|" BanqueId
	if {[regexp "mol\:protein" $Access]} { set Access $BanqueId }
	set BANQUEID [string toupper $BanqueId]
	set ACCESS   [string toupper $Access]
	if {[info exists DejaVu($BANQUEID)] || [info exists DejaVu($ACCESS)]} {
	    FaireLire "Deja vu $BanqueID $Access !! "
	}
	set Beau($BANQUEID)  $BanqueId
	set Beau($ACCESS)    $Access
	if {$BANQUEID!=$ACCESS} {
	    set Autre($BANQUEID) $ACCESS
	    set Autre($ACCESS)   $BANQUEID
	}
    }

    set NouveauxAnchors {}
    foreach Ligne [LesLignesDuFichier $FichierAnchors] {
	set NouvelleLigne $Ligne
	if { ! [regexp "^seq\:" $Ligne]} { lappend NouveauxAnchors $NouvelleLigne ; continue }
	set AccessAnchor ""
	scan $NouvelleLigne "%s %s %s" Seq QueryLue AccessAnchor
	if {[info exists BETTERQUERY($QueryLue)]} {
	    set Better $BETTERQUERY($QueryLue)
	    if {[regexp -indices $QueryLue $NouvelleLigne Indices]} {
		lassign $Indices D F
		set L [string length $Better]
		if {$L>=$F-$D+1} {
		    set F [expr $D+$L-1]
		} else {
		    set L [expr $F-$D]
		    set Better [string range "$Better                 " 0 $L]
		}
		set NouvelleLigne [string replace $NouvelleLigne $D $F $Better]
	    }
	}
	set ACCESSANCHOR [string toupper $AccessAnchor]
	if { ! [info exists MauvaisAnchors($ACCESSANCHOR)]} {
	    lappend NouveauxAnchors $NouvelleLigne
	    continue
	}
	if { ! [info exists Autre($ACCESSANCHOR)]} {
	    if { [EstUnAccessPDB $ACCESSANCHOR] && [regexp "_$" $ACCESSANCHOR]} {
		regsub "_$" $ACCESSANCHOR "" AUTREACC
	    } else {
		lappend NouveauxAnchors $Ligne
		continue
	    }
	} else {
	    set AUTREACC [set Autre($ACCESSANCHOR)]
	}
	if { ! [info exists EstDansTFA($AUTREACC)]} {
	    lappend NouveauxAnchors $NouvelleLigne
	    continue
	}
	set BeauNouveau [set Beau($AUTREACC)]
	set NouvelleLigne [SubstitueAvecBlancsDevant $NouvelleLigne $AccessAnchor $BeauNouveau]
	lappend NouveauxAnchors $NouvelleLigne
    }
    SauveLesLignes $NouveauxAnchors dans "$FichierAnchors.coherent2"
    return [SauveLesLignes $NouveauxAnchors dans "$FichierAnchors.coherent"]
}

proc FichierAnchorsPour Nom {
    global RepertoireDuGenome
    global OptionsBallastPourJulie

    set FichierAnchors "$RepertoireDuGenome/ballast/$Nom.anchors"
    if {[file exists $FichierAnchors]} { return $FichierAnchors }

    Wup "Il faut le creer"

    set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"

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

    if { ! [info exists OptionsBallastPourJulie] \
	    && [file exists "$RepertoireDuGenome/ballast/$Nom"]} {
	set FichierBallast "$RepertoireDuGenome/ballast/$Nom" 
    } else { 
	set FichierBallast [Ballast $FichierBlastP]
    }
    if {$FichierBallast != "" && \
	    [regexp -nocase "fatal error" [join [LesPremieresLignesDuFichier $FichierBallast 10]] "\n"]} {
	set FichierBallast ""
    }
    if {$FichierBallast==""} { return "" }
    return "$FichierBallast.anchors"
}

proc LesOrganismesImportantsPourDBClustal {{Ask ""}} {
    global RepertoireDuGenome
    global GscopeDir
    global LesOrganismesImportantsPourDBClustal

    set Ask [regexp -nocase "^Ask$" $Ask]

    if {! $Ask && [info exists LesOrganismesImportantsPourDBClustal]} {
	return $LesOrganismesImportantsPourDBClustal
    }
    
    set FichierOrgImportant "$RepertoireDuGenome/fiches/orgimportant"
    if {$Ask || ! [file exists $FichierOrgImportant]} {
	set FichierOrgImportantDefaut "$GscopeDir/gscope_orgimportant"
	if {[file exists $FichierOrgImportantDefaut] && \
		[OuiOuNon "Do I copy the file \n\
		$FichierOrgImportantDefaut\n\
		to $FichierOrgImportant\n ?"]} {
	    File copy $FichierOrgImportantDefaut $FichierOrgImportant
	} else {
	    while {[OuiOuNon "Do You want to load an existing file with Important Organisms ?"]} {
		set F [ButineArborescence "All" $RepertoireDuGenome]
		if {$F==""} { continue }
		if {[OuiOuNon "Do I copy it to $FichierOrgImportant ?"]} {
		    File copy -force $F $FichierOrgImportant
		} else {
		    set FichierOrgImportant $F
		}
		break
	    }
	}
    }
    
    if {[file exists $FichierOrgImportant]} {
	set LesOIs [LesLignesDuFichier $FichierOrgImportant]
    } else {
	lappend LesOIs "### Important organisms for DBClustal"
	lappend LesOIs "#   You can modify these lines."
	lappend LesOIs "#      please respect Upper-lower case ( Homo sapiens )"
	lappend LesOIs "#      use 'remove' to remove an organism."
	lappend LesOIs "#      nothing to add a new organism."
	lappend LesOIs "#      use 'addall' to tell to Gscope to add all these returned by the function"
	lappend LesOIs "#      use 'remall' to tell to Gscope to remove these"
	lappend LesOIs "#"
	lappend LesOIs "#   If one organism appears two times, the first command has priority"
	lappend LesOIs "###"
	lappend LesOIs "Pyrococcus furiosus"
	lappend LesOIs "remove Pyrococcus furiosus"
	lappend LesOIs "remove Homo sapiens"
	lappend LesOIs "Homo sapiens"
	lappend LesOIs "addall LesGenomesComplets"
	set Ask 1
    }

    while {$Ask && [OuiOuNon "Do You want to edit the Important Organisms List ?" 0]} {
	set OIs [EntreTexte [join $LesOIs "\n"]]
	if {$OIs==""} { continue } 
	set LesOIs [split $OIs "\n"]
	if {[OuiOuNon "Do I save these organisms in \n $FichierOrgImportant ?"]} {
	    SauveLesLignes $LesOIs dans $FichierOrgImportant
	}
	break
    }

    set LesOrganismesImportants {}
    foreach Ligne $LesOIs {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	if {[regexp " *#+" $Ligne]} { continue }
	if {[regexp "^(addall |remall )" $Ligne Match]} {
	    set Commande [StringSuivant "$Match" dans $Ligne]
	    foreach O [eval $Commande] {
		if {[info exists DejaVu($O)]} { continue }
		set DejaVu($O) 1
		if {$Match=="addall "} { lappend LesOrganismesImportants $O }
	    }
	    continue
	}
	set RemoveMoi [regexp "^remove " $Ligne] 
	regsub "^remove +" $Ligne "" O
	if {[info exists DejaVu($O)]} { continue }
	set DejaVu($O) 1
	if {$RemoveMoi} { continue }
	lappend LesOrganismesImportants $O
    }
    set LesOrganismesImportantsPourDBClustal $LesOrganismesImportants
    return $LesOrganismesImportants
}

proc TailleSortiePourDBClustal {{Ask ""}} {
    global RepertoireDuGenome
    global GscopeDir
    global TailleSortiePourDBClustal

    set Ask [regexp -nocase "^Ask$" $Ask]

    if {! $Ask && [info exists TailleSortiePourDBClustal]} {
	return $TailleSortiePourDBClustal
    }

    set FichierTailleSortie "$RepertoireDuGenome/fiches/sizemsf"
    if { $Ask || ! [file exists $FichierTailleSortie]} {
	set FichierTailleSortieDefaut "$GscopeDir/gscope_sizemsf"
	if {[file exists $FichierTailleSortieDefaut] && \
		[OuiOuNon "Do I copy the file \n\
		$FichierTailleSortieDefaut\n\
		to $FichierTailleSortie\n ?"]} {
	    File copy $FichierTailleSortieDefaut $FichierTailleSortie
	} else {
	    while {[OuiOuNon "Do You want to load an existing file with output sizes for dbclustal ?"]} {
		set F [ButineArborescence "All" $RepertoireDuGenome]
		if {$F==""} { continue }
		if {[OuiOuNon "Do I copy it to $FichierTailleSortie ?"]} {
		    File copy -force $F $FichierTailleSortie
		} else {
		    set FichierTailleSortie $F
		}
		break
	    }
	}
    }
    
    if {[file exists $FichierTailleSortie]} {
	set VT [ContenuDuFichier $FichierTailleSortie]
    } else {    
	set VT "40 70 30 0.001  respectively : at_least max_with_complete_genomes max_pdb expect"
	set Ask 1
    }
    while {$Ask && [OuiOuNon "Do You want to modify the output sizes ?"]} {
	set NewVT [Entre $VT]
	if {$NewVT==""} { continue }
	set VT $NewVT
	if {[OuiOuNon "Do I save these values in $FichierTailleSortie ?"]} {
	    Sauve $VT dans $FichierTailleSortie
	}
    }
    set TailleSortiePourDBClustal $VT
    return $VT
}

proc LesCandidatsPourClustalW {FichierOuNom {Source ""}} {
    global RepertoireDuGenome
    global SeuilExpectPourJulie

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

    set Nom [file tail $FichierOuNom]

    scan [TailleSortiePourDBClustal] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect 

    if {[info exists SeuilExpectPourJulie]} {
	set SeuilExpect $SeuilExpectPourJulie
    }

    Wup "On ne veut plus voir le meme PAB .......... peut servir autrement ... "
    set LesIndesirables {}
    if {0 && [regsub "^ABY$" $Nom "PAB" Indesirable]} {
	lappend LesIndesirables $Indesirables
    }

    if { $Source=="apnosoc"} {
	set FichierApnOsOc "$RepertoireDuGenome/apnosoc/$Nom"
	if {[file exists $FichierApnOsOc]} { 
	    set LesCandidats [LesLignesDuFichier "$RepertoireDuGenome/apnosoc/$Nom"]
	} else {
	    return {}
	}
    } elseif { $Source=="blastp" || $Source=="ballast"} {
	set LesCandidats {}
	if {[file exists $FichierOuNom]} {
	    set FichierBallast $FichierOuNom
	} else {
	    set FichierBallast "$RepertoireDuGenome/$Source/$Nom"
	}
	if { ! [file exists $FichierBallast]} { return {} }
	DecortiqueBlast $FichierBallast $SeuilExpect "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
	PrepareLesSequencesDesBanques $lBanqueId $lAccess
	foreach BanqueId $lBanqueId Access $lAccess Profil $lProfil PN $lPN {
	    set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
	    DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX 
	    if {[lsearch -exact $LesIndesirables $Access] > 0 } { continue }
	    Wup "Si ballast, on ne prend que ceux qui ont contribue au profil"
	    if {0 && $Source=="ballast" && ! $Profil} { continue }
	    lappend LesCandidats "$BanqueId $Access $PN $OS $OC"
	    regsub -all {\:} $DE "_" DE
	    set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX: $OX"
	    StockeLeDescriptif $AccessOK $Descriptif $Nom
	}
    }
    return $LesCandidats
}

proc ReordonneLeFichierMSF {Fichier LesAccess {Nom ""}} {

    if { ! [file exists $Fichier]} {
	set Fichier "[RepertoireDuGenome]/msf/$Fichier"
    }
    if { ! [file exists $Fichier]} { return "" }
    if {$Nom==""} { set Nom [file tail $Fichier] }
    set MSF [ContenuDuFichier $Fichier]
    return [ReordonneMSF $MSF $LesAccess $Nom]
}

proc ReordonneMSF {MSF LesAccess {Nom ""}} {
    while 1 {
	if {$Nom!="" && $LesAccess=="Disphy"} {
	    set LesAccess [concat [list $Nom] [FromDisphy $Nom]]
	    break
	}
	if {$LesAccess=="Secator"} {
	    set FiMSF [Sauve $MSF dans [TmpFile "secator"]] 
	    set LesAccess [GroupeSecator $FiMSF "" "ToutLeMondeAvecGroupe" "ToCalculate"]
	    break
	}
	if {$LesAccess=="Dpc"} {
	    FaireLire "It's not yet possible to reorder with Dpc"
	    return ""
	    set FiMSF [Sauve $MSF dans [TmpFile "dpc"]] 
	    set LesAccess [GroupeDpc $FiMSF "" "ToutLeMondeAvecGroupe" "ToCalculate"]
	    break
	}
	if {$LesAccess=="Oumy"} {
	    FaireLire "It's not yet possible to reorder with Oumy"
	    return ""
	    set FiMSF [Sauve $MSF dans [TmpFile "oumy"]] 
	    set LesAccess [GroupeOumy $FiMSF "" "ToutLeMondeAvecGroupe" "ToCalculate"]
	    break
	}
	break
    }
    set i 0
    foreach Ligne $LesAccess {
	scan $Ligne "%s" Access
	set ACCESS [string toupper $Access]
	set RangDuAccess($ACCESS) [incr i]
    }
    set LeMSF [split $MSF "\n"]
    lappend LeMSF "UneLignePourFinir"
    foreach Ligne $LeMSF {
	if { ! [regexp -nocase {[a-z]+} $Ligne] || \
		[regexp "^PileUp|MSF: " $Ligne]} {
	    if {[info exists GroupeCourant]} {
		set GroupeCourant [lsort -integer -index 0 $GroupeCourant]
		foreach iLi $GroupeCourant {
		    set Li [lindex $iLi 1]
		    lappend LeNouveau $Li
		}
		unset GroupeCourant
	    }
	    if {$Ligne=="UneLignePourFinir"} { break }
	    lappend LeNouveau $Ligne
	    continue
	}
	scan $Ligne "%s %s" Name Access
	if {$Name!="Name:"} { set Access $Name }
	set ACCESS [string toupper $Access]
	if {[info exists RangDuAccess($ACCESS)]} {
	    lappend GroupeCourant [list [set RangDuAccess($ACCESS)] $Ligne]
	}
    }
    return [join $LeNouveau "\n"]
}