#rR gscope/gscope_closig.tcl

proc CorrigeFichiersSequencage {} {
    set LesFiFas [lsort [glob -nocomplain *.fas]]
    foreach FiFas $LesFiFas {
	regsub {\.fas$} $FiFas "" Access
	regsub {\.fas$} $FiFas ".tfa" FiTfa
	if {[file exists $FiTfa]} { continue }
	set Fas [ContenuDuFichier $FiFas]
	regsub ">" $Fas ">$Access " Tfa
	Sauve $Tfa dans $FiTfa
	Espionne $FiTfa
    }
}

proc CorrigeLesRebuildedBrocOli {} {
    FaireLire "ne pas relancer."
    exit
    set LesFichiers [lsort [glob "[RepertoireDuGenome]/oligos/*.tfa"]]
    foreach Fichier $LesFichiers {
	set P [file tail $Fichier]
	regsub ".tfa" $P "" P
	set TFA [ContenuDuFichier $Fichier]
	if { ! [regexp "Rebuilded" $TFA]} { continue }
	if { ! [regexp {\+} $TFA]} { continue }
	set Rac [QueLaSequenceDuTexteTFA $TFA]
	set Seq [NucToReverseAndComplementNuc $Rac]
	set Ensembles [StringApres "with signal" dans $TFA]
	set LesEnsembles [split $Ensembles "+"]
	foreach Signaux $LesEnsembles {
	    set LesSignal [split $Signaux "_"]
	    set LesSignalInverse [RetourneLaListe $LesSignal]
	    set Trouve ""
	    set Gagne 1
	    foreach NS $LesSignalInverse {
		set S [Signal $NS "SEQ"]
		if { ! [regexp -nocase $S $Seq]} {set Gagne 0 ;  break }
		append Trouve " $NS"
	    }
	    if {$Gagne} {
		Espionne "$P $Signaux $Trouve"
		set I [string first $Signaux $Ensembles]
		set Vide [string repeat " " $I]
		Espionne "il faudrait remplacer \n$Ensembles\n$Vide$Signaux"
	    }
	    regsub -all {\+} $Ensembles "\\+" E
	    regsub $E $TFA $Signaux NewTFA
	    Espionne $NewTFA
	    Sauve $NewTFA dans $Fichier
	}
    }
    exit
}

proc CorrigeGluOli {} {
    foreach Fichier [glob "[RepertoireDuGenome]/atelier/OligosKeeper/OligosKeeper2008071*.nots"] {
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if { ! [regexp "BrocOli" $Ligne]} { lappend New $Ligne ; continue }
	    regsub ">" $Ligne "" Ligne
	    scan $Ligne "%s %s %s %s %s %s" A BrocOli With B Replaces C
	    set LesA [split $A "+"]
	    Espionne $LesA
	    set LesA [ListeSansDoublon $LesA]
	    Espionne $LesA
	}
    }
    exit
}

proc lso {} {
    set L [LesLignesDuFichier lso]
    set FichierCommande "usethisname_/genomics/link/ProGS/atelier/Arnaud/AFaire20061010.txt"
    CommandeOligos $L $FichierCommande
}

proc LeFichierDesSignaux {{Choix ""}} {
    set Choix [regexp -nocase {^Cho} $Choix]
    if {$Choix} { return [lindex [LesFichiersDeType "Signaux"] 0] }
    set Fichier "[RepertoireDuGenome]/signaux/signaux.tfa"
    if {[file exists $Fichier]} { return $Fichier }
    set Fichier "/genomics/link/ProGS/signaux/signaux.tfa"
    if {[file exists $Fichier]} { return $Fichier }
    FaireLire "I cna't find the signel file ... Please browse for it."
    return [ButineArborescence "All" "./"]
}

proc OligAuto {{Fichier ""}} {

    set RepDesFragments "."

    if {$Fichier==""} { set Fichier [ButineArborescence "All" "./"] }
    if {[FileAbsent $Fichier]} { return "" }
    set FichierCommande "usethisname_$Fichier"

    set Racine [file tail $Fichier]
    regsub ".txt" $Racine "" Racine
    foreach Ligne [LesLignesVitales $Fichier "SansVide" "AvecBlanc"] {
#	regsub -all { +\-}  $Ligne "-" Ligne
#	regsub -all {\- +}  $Ligne "-" Ligne
#	regsub -all " "  $Ligne "_" Ligne
#	regsub -all {_+} $Ligne "_" Ligne
	regsub -all { }  $Ligne ""  Ligne
	regsub -all {_+} $Ligne "_" Ligne
	set Ligne [string trim $Ligne " _"]
Espionne $Ligne
	if {[regexp "@" $Ligne]} {
	    lassign [split $Ligne "@"] Avant GeneOperon GeneA GeneB Apres
	    set NameA [lrange [split $GeneA "-"] 0 end-2]
	    set NameB [lrange [split $GeneB "-"] 0 end-2]
	    set Nom [NomDuAlias $GeneOperon]
	    if {$Nom==""} { FaireLire "I don't know $GeneOperon in \n$Ligne\nI'll skip"; continue; }
	    set AS [OperonClonage $Nom $NameA "GetStart"]
	    set BS [OperonClonage $Nom $NameB "GetStart"]
	    if {$AS=="" || $BS==""} { FaireLire "$Nom $GeneOperon $NameA $NameB in \n$Ligne\nis not an operon.AS=$AS==BS=$BS= I'll skip"; continue; }
	    set ADaa [lindex [split $GeneA "-"] end-1]
	    set BFaa [lindex [split $GeneB "-"] end]
	    set AD [expr ($ADaa-1)*3] 
	    set BF [expr ($BFaa-1)*3+2] 
	    set D  [expr $AS + $AD]
	    set F  [expr $BS + $BF]
	    set Frag "$GeneOperon-b$D-b$F"
	    set Ligne "$Avant$Frag$Apres"
	}
	ScanLaListe [DecomposeLaLigne $Ligne] LesSujets LesAvs LesAps
	Espionne
	Espionne "Ligne  : $Ligne"
	Espionne "Sujets : $LesSujets"
	Espionne "Avants : $LesAvs"
	Espionne "Apress : $LesAps"
	set AvsAps "[join $LesAvs "_"]//[join $LesAps "_"]"
	lappend LesAvsAps $AvsAps
	set OnEstEnNuc 0
	foreach Sujet $LesSujets {
	    Espionne "Sujet  : $Sujet"
	    set TestStopAtTheEnd 0
	    if {[regexp -nocase {\-([0-9]+)\-(end|stop)$} $Sujet Match D F]} {
		regsub -- "\-$D\-$F$" $Sujet "" Alias
		if {[string equal -nocase $F "end"] } { set F "EndWithoutStop" } 
		if {[string equal -nocase $F "stop"]} { set F "End" ; set TestStopAtTheEnd 1} 
	    } elseif {[regexp {\-([0-9]+)\-([0-9]+)$} $Sujet Match D F]} {
		regsub -- "\-$D\-$F$" $Sujet "" Alias
	    } elseif {[regexp {\-b([0-9]+)\-b([0-9]+)$} $Sujet Match D F]} {
		set OnEstEnNuc 1
		regsub -- "\-b$D\-b$F$" $Sujet "" Alias
		set D "b$D"
		set F "b$F"
	    } else {
		set Alias $Sujet
		set D 1
		set F "EndWithoutStop"
	    }
	    if {[EstUnPAB $Alias]} {
		set Nom $Alias
		set Alias [Alias $Nom]
	    } else {
		set Nom [NomDuAlias $Alias]
	    }
	    if { ! [EstUnPAB $Nom]} { 
		if {[OuiOuNon "I didn't find the PGS $Nom for the Alias $Alias\nDo I skipp\n$Sujet"]} { continue }
	    }
	    if {[regexp -nocase "^End" $F]} {
		set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
		set L [string length $Seq]
		set CodonStop [string range $Seq [expr $L-3] [expr $L-1]]
		Espionne "$L $CodonStop"
		if {$TestStopAtTheEnd && ! [CodonStopPossible $CodonStop]} {
		    if {[OuiOuNon "You expected a Stop at the end of $Sujet but it doesn't exist.\nDo I skip ?"]} { continue }
		}
		set FN $L
		if {[regexp -nocase "WithoutStop" $F] && [CodonStopPossible $CodonStop]} { incr FN -3 }
		set F [expr $FN/3]
	    }
	    set Fragment "$Nom $D $F $Alias"
	    Espionne "Fragment : $Fragment"
	    lappend LesFragmentsDesAvsAps($AvsAps) $Fragment
	    lappend LesAvsApsDuFragment($Fragment) $AvsAps
	}
    }
    set LesAvsAps [lsort -unique $LesAvsAps]
    Espionne "****************************************************"
    Espionne
    EspionneL $LesAvsAps
    FaireLire "I'll have to create the files needed to create\
	    \n the fragments\ntthe construction\nthe signal-construction order\n... \nPlease browse for the directory"
    set RepDesFragments [ChoixDuRepertoire $RepDesFragments]
    set FichierDesSignaux [LeFichierDesSignaux]
    foreach AvsAps $LesAvsAps {
	Espionne "for AvsAps : $AvsAps"
	EspionneL $LesFragmentsDesAvsAps($AvsAps)

	regsub "//" $AvsAps " " AA
	ScanLaListe [split $AA " "] Avs Aps
	set LesAvs [split $Avs "_"]
	set LesAps [split $Aps "_"]

	set FichierFrag "$RepDesFragments/$Avs-$Racine-$Aps.frag"
	while {[file exists $FichierFrag] && [OuiOuNon "$FichierFrag already exists. Choose an other name ?" 0]} { 
	    set FichierFrag [FichierPourSaveAs $FichierFrag]
	}
	set FichierFrag [SauveLesLignes $LesFragmentsDesAvsAps($AvsAps) dans $FichierFrag]
	regsub ".frag$" $FichierFrag ".tfa" FichierTFAs
	while {[file exists $FichierTFAs] && [OuiOuNon "$FichierTFAs already exists. Choose an other name ?" 0]} { 
	    set FichierTFAs [FichierPourSaveAs $FichierTFAs]
	}
	set FichierTFAs [GenereFragments "Predefinis" $FichierFrag "" $FichierTFAs]
	set SavSapFavFap [list $LesAvs $LesAps $FichierDesSignaux $FichierDesSignaux]
	set OliPPCR [OligosEtProduitsPCR $FichierTFAs $SavSapFavFap]
	set FichierOligos [lindex $OliPPCR 0]
	lappend LesFichiersOligos $FichierOligos
    }
    return [CommandeOligos $LesFichiersOligos $FichierCommande]
}

proc MultiplesSujetsDesP {} {
    foreach P [Oli "LaListeMerci"] {
	set LesSujets [Oli $P Subjects]
	set LesSujetsTries [ListeSansDoublon $LesSujets]
	if {[llength $LesSujets]!=[llength $LesSujetsTries]} {
	    set Sujets [join $LesSujets " "]
	    set SujetsTries [join $LesSujetsTries " "]
	    set TFA [Oli $P TFA]
	    regsub $Sujets $TFA $SujetsTries New
	    FaireLire "$TFA\n$New" 
#	    Sauve $New dans "[RepertoireDuGenome]/oligos/$P.tfa"
	}
    }
    exit
}

proc RecupereLesVieuxP {} {
    FaireLire "obsolete"
    foreach P [LesLignesDuFichier lili] {
	if {$P==""} { continue }
	set N [RepertoireDuGenome]/oligos/$P.tfa
	set V [RepertoireDuGenome]/oligos.20060608/$P.tfa
	Espionne [ContenuDuFichier $N]
	Espionne [ContenuDuFichier $V]
	Sauve [ContenuDuFichier $V] dans $N
    }
    exit
}

proc MiseAJourDesPDesExistings {} {
    foreach Fichier [lsort [glob "[RepertoireDuGenome]/atelier/*/*existing*.list"]] {
	Espionne $Fichier
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	    scan $Ligne "%s %s %s %s" Existant please use P
	    if {[Oli $P "Type"]=="IgnoreOli"} { continue }
	    if {[Oli $P "Type"]=="MutOli"} { continue }
	    set LesSS [split $Existant "_"]
	    if {[Oli $P Sens]=="5'"} {
		set Existant [lindex $LesSS end]
	    } else {
		set Existant [lindex $LesSS 0]
	    }
		
	    set Vu 0
	    if { ! [info exists LesSujets($P)]} {
		set LesSujets($P) [Oli $P "Subjects"]
		set TFA($P) [Oli $P "TFA"]
	    }
	    foreach Sujet $LesSujets($P) {
		if {[string equal $Sujet $Existant]} { set Vu 1 ; break }
	    }
	    if {$Vu} { Espionne "Vu $Existant dans $P" ; continue }
	    lappend LesSujets($P) $Existant
	    if {[regexp " RebuildedBrockenOli " $TFA($P)]} {
		regsub  " RebuildedBrockenOli " $TFA($P) " $Existant RebuildedBrockenOli " TFA($P)
	    } elseif {[regexp " BrocOli " $TFA($P)]} {
		regsub  " BrocOli " $TFA($P) " $Existant BrocOli " TFA($P)
	    } else {
		regsub "\n" $TFA($P) " $Existant\n" TFA($P)
	    }
	    Espionne ""
	    Espionne $Existant
	    Espionne $TFA($P)
	    Sauve $TFA($P) dans "[RepertoireDuGenome]/oligos/$P.tfa"
	}
    }
}

proc TousSens {} {
    foreach P [Oli "LaListeMerci"] {
	Espionne $P
	Espionne [Oli $P "Sens"]
    }
}

proc CorrigeLesSujetsDesMultiples {} {
    foreach P [Oli "LaListeMerci"] {
	set LesSubjects [Oli $P "Subjects"]
	set Signals [Oli $P "Signals"]
	foreach Sujet $LesSubjects {
	    if {[Oli $P "Sens"]=="5'"} {
		set SS "${Signals}_$Sujet"
		lappend LesPsDuSS($SS) $P
		regsub {\-[0-9]+$} $SS "" SSDebut
		lappend LesPsDuSS($SSDebut) $P
		lappend LesPsDuSS($SSDebut,Complet) $SS
	    } else {
		set SS "${Sujet}_$Signals"
		lappend LesPsDuSS($SS) $P
		if { ! [regexp {\-([0-9]+)\-([0-9]+)_} $SS Match Deb Fin]} { continue }
		regsub {\-([0-9]+)\-([0-9]+)$} $Sujet "" Gene
		lappend LesPsDuSS($Gene,$Fin) $P
		lappend LesPsDuSS($Gene,$Fin,Complet) $SS
	    }
	}
    }
    foreach FO [glob -nocomplain "[RepertoireDuGenome]/atelier/*/oligos_*.tfa"] {
	set Rep [file dirname $FO]
	set ShowFO 1
	foreach Access [LaSequenceDuTFAs $FO "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $FO $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    scan $Entete "%s" SS
	    regsub ">" $SS "" SS
	    if {[regexp "SeqOli_" $SS]} { continue }
	    if {[info exists LesPsDuSS($SS)]} { continue }
	    Espionne $SS
	    if {[regexp "^AttB1" $SS]} { continue }
	    if { ! [regexp {\-([0-9]+)\-([0-9]+)_} $SS Match Deb Fin]} { continue }
	    regsub {\-([0-9]+)\-([0-9]+)_.+} $SS "" Gene
	    Espionne "$SS $Gene $Deb $Fin"
	    if {[info exists LesPsDuSS($Gene,$Fin)]} {
		if {$ShowFO} { Espionne "\n$FO" ; set ShowFO 0 }
		Espionne "pas de ref pout $SS"
		set P $LesPsDuSS($Gene,$Fin)
		scan $P "%s" P
		if {[info exists MeilleurDP($P)]} {
		    set DP $MeilleurDP($P)
		} else {
		    set DP [Oli $P Description]
		}
		set Sujet "$Gene-$Deb-$Fin"
		set DPOk "$DP $Sujet"
		set MeilleurDP($P) $DPOk
		Espionne "$SS\n$Deb $Fin\n$LesPsDuSS($Gene,$Fin,Complet)"
		Espionne "  $DP\n  $DPOk"
		set SeqP [Oli $P "Seq"]
		set BonP [SequenceFormatTFA $SeqP $DPOk]
		Espionne $BonP
		Sauve $BonP dans "[RepertoireDuGenome]/oligos/$P.tfa"
	    } else {
		if {$ShowFO} { Espionne $FO ; set ShowFO 0 }
		Espionne "$SS introuvable" 
	    }
	}
    }
    exit
}

proc CorrigeLesSujetsDesBrocoli {} {
    foreach P [Oli "LaListeMerci"] {
	set LesSubjects [Oli $P "Subjects"]
	set Signals [Oli $P "Signals"]
	foreach Sujet $LesSubjects {
	    set SS "${Signals}_$Sujet"
	    regsub {\-[0-9]+$} $SS "" SSDebut
	    lappend LesPsDuSS($SS) $P
	    lappend LesPsDuSS($SSDebut) $P
	    lappend LesPsDuSS($SSDebut,Complet) $SS
	}
    }
  
    foreach FO [glob -nocomplain "[RepertoireDuGenome]/atelier/*/oligos_*.tfa"] {
	set Rep [file dirname $FO]
	set ShowFO 1
	foreach Access [LaSequenceDuTFAs $FO "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $FO $Access]
	    set Entete [EnteteDuTexteTFA $TFA]
	    if { ! [regexp "^>AttB1_" $Entete]} { continue }
	    scan $Entete "%s" SS
	    regsub ">" $SS "" SS
	    if {[info exists LesPsDuSS($SS)]} { continue }

	    set Sujet [lindex [split $SS "_"] end]
	    regsub {\-[0-9]+$} $SS "" SSDebut	    
	    if {[info exists LesPsDuSS($SSDebut)]} {
		if {$ShowFO} { Espionne "\n$FO" ; set ShowFO 0 }
		Espionne "pas de ref pout $SS"
		set P $LesPsDuSS($SSDebut)
		scan $P "%s" P
		if {[info exists MeilleurDP($P)]} {
		    set DP $MeilleurDP($P)
		} else {
		    set DP [Oli $P Description]
		}
		regsub " RebuildedBrockenOli" $DP " $Sujet RebuildedBrockenOli" DPOk
		set MeilleurDP($P) $DPOk
		set B [Oli $P "Brocken"]
		if {[info exists MeilleurDB($B)]} {
		    set DB $MeilleurDB($B)
		} else {
		    set DB [Oli $B Description]
		}
		regsub " BrocOli" $DB " $Sujet BrocOli" DBOk
		set MeilleurDB($B) $DBOk
		Espionne "$SS\n$SSDebut\n$LesPsDuSS($SSDebut,Complet)\n$DP\n$DPOk\n$DB\n$DBOk\n"
		set SeqP [Oli $P "Seq"]
		set BonP [SequenceFormatTFA $SeqP $DPOk]
		Espionne $BonP
		Sauve $BonP dans "[RepertoireDuGenome]/oligos/$P.tfa"
		set SeqB [Oli $B "Seq"]
		set BonB [SequenceFormatTFA $SeqB $DBOk]
		Espionne $BonB
		Sauve $BonB dans "[RepertoireDuGenome]/oligos/$B.tfa"
	    } else {
		if {$ShowFO} { Espionne $FO ; set ShowFO 0 }
		Espionne "$SS introuvable" 
	    }
	    set LesSignaux [lrange [split $SS "_"] 0 end-1]
	    set Sujet [lindex [split $SS "_"] end]
	}
    }
    exit
}

proc AfficheZoneContigue {Fichier {Selection ""}} {
    if {$Selection==""} { set Selection "FirstOnly" }
    if {[regexp "\n" $Selection]} {
	set AliasALaFin ""
	foreach Access [split $Selection "\n"] {
	    if {[regexp {^ *Alias } $Access]} {
		set AliasALaFin $Access
		continue
	    }
	    AfficheZoneContigue $Fichier $Access 
	}
	if {$AliasALaFin!=""} { AfficheZoneContigue $Fichier $AliasALaFin }
	return
    }
    
    set Access ""
    scan $Selection "%s %s" Nature Access
    if {$Access==""} { set Access $Nature }
    
    set LesHomologues [LesHomologiesDuBlastN $Fichier "AvecLaSeq" "" "SansOrga" $Access]
    foreach Homo $LesHomologues {
	set lHomo [split $Homo "\t"]
	set i -1
	set Nom        [lindex $lHomo [incr i]]
	set nCops      [lindex $lHomo [incr i]]
	set nCopsSeq   [lindex $lHomo [incr i]]
	set BanqueId   [lindex $lHomo [incr i]]
	set OrgaHomo   [lindex $lHomo [incr i]]
	set Identities [lindex $lHomo [incr i]]
	set Expect     [lindex $lHomo [incr i]]
	set DebutQuery [lindex $lHomo [incr i]]
	set FinQuery   [lindex $lHomo [incr i]]
	set DebutSbjct [lindex $lHomo [incr i]]
	set FinSbjct   [lindex $lHomo [incr i]]
	set SeqQuery   [lindex $lHomo [incr i]]
	set SeqSbjct   [lindex $lHomo [incr i]]

	set SensSbjct 1
	if {$FinSbjct < $DebutSbjct} { set SensSbjct -1 }

	set iQ $DebutQuery
	set iQTexte ""
	set iQTexteEstVide 1
	set iS $DebutSbjct
	set iSTexte ""
	set iSTexteEstVide 1
	set ConMax -1
	set ConCourant 0
	set ConDebCourantQ -1
	set ConDebCourantS -1
	set Peigne  ""
	set PeigneN ""
	set ConDebQ -3
	set iP 1
	foreach Q [split $SeqQuery ""] S [split $SeqSbjct ""] {
	    if {[expr $iQ%10==0] && $Q!="-" } {
		set iQTexteEstVide 0
		append iQTexte [string range "$iQ          " 0 9]
	    } else {
		if {$iQTexteEstVide} { append iQTexte " " }
	    }
	    if {[expr $iS%10==0] && $S!="-" } {
		set iSTexteEstVide 0
		append iSTexte [string range "$iS          " 0 9]
	    } else {
		if {$iSTexteEstVide} { append iSTexte " " }
	    }
	    if {[string equal -nocase "N" $Q]} { append PeigneN "N" } else { append PeigneN " " }
	    if {[string equal -nocase $Q $S] || [string equal -nocase "N" $Q]} {
		append Peigne "|"
		incr ConCourant
		if {$ConDebCourantQ==-1} {
		    set ConDebCourantP $iP
		    set ConDebCourantQ $iQ
		    set ConDebCourantS $iS
		} 
		if { ! [info exists ConFinQ]} {
		    set ConFinP $iP
		    set ConFinQ $iQ
		    set ConFinS $iS
		}
		if {$ConCourant>$ConMax} {
		    set ConMax  $ConCourant
		    set ConFinP $iP
		    set ConFinQ $iQ
		    set ConFinS $iS
		    if {$ConDebQ!=$ConDebCourantQ} {
			set ConDebP $ConDebCourantP
			set ConDebQ $ConDebCourantQ
			set ConDebS $ConDebCourantS
		    }
		}
	    } else {
		set ConCourant 0
		append Peigne " "
		set ConDebCourantP -1
		set ConDebCourantQ -1
		set ConDebCourantS -1
	    }
	    incr iP
	    if {$Q!="-"} { incr iQ            } else { append iQTexte " " }
	    if {$S!="-"} { incr iS $SensSbjct } else { append iSTexte " " }
	}

	set iDebPeigne [expr $ConDebP - 1]
	set iFinPeigne [expr $ConFinP - 1]
	set lPeigne [expr $iFinPeigne - $iDebPeigne +1]
	set Peigne [string replace $Peigne $iDebPeigne $iFinPeigne [string repeat "+" $lPeigne]]

	if {$SensSbjct==1} {
	    set BonConDebS $ConDebS
	    set BonConFinS $ConFinS
	    set EtLeSens ""
	} else {
	    set BonConDebS $ConFinS
	    set BonConFinS $ConDebS
	    set EtLeSens "CAUTION: reverse"
	}
	lappend LaPage "$Access hit in $Fichier : $lPeigne contigous identical bases"
	lappend LaPage [format "%5d %5d %s"    $ConDebQ    $ConFinQ "from sequenced"]
	lappend LaPage [format "%5d %5d %s" $BonConDebS $BonConFinS "from $Access $EtLeSens"]
	global TextePourInformeVerificationSequencage
	set TextePourInformeVerificationSequencage "$BonConDebS-$BonConFinS"
	lappend LaPage $PeigneN
	lappend LaPage $iQTexte 
	lappend LaPage $SeqQuery
	lappend LaPage $Peigne
	lappend LaPage $SeqSbjct
	lappend LaPage $iSTexte
	set Page [join $LaPage "\n"]
	AfficheVariable $Page "" "${Fichier}_$Access"
    }
}

proc CreeLaBaseSqlonage {} {
    set Handle [mysqlconnect -host localhost -user root]
    mysqlexec $Handle {create database if not exists Sqlonage;}
    mysqluse  $Handle "Sqlonage"
    return $Handle
}

proc CreeLaTableSignals Handle {

    set Status [mysqlexec $Handle {
	create table if not exists Signals (
	PK integer,
	Name varchar(64), 
	Seq  varchar(254), 
	Description varchar(254),
	primary key (id)
	); 
    }]
    return $Status
}

proc StoreSignal {} {
}

proc EtatsDesVE {{Qui ""} {Quoi ""} {Quoi2 ""}} {
    global EtatsDesVE 

    if {$Qui=="MeilleurTask"} {
	set ME [EtatsDesVE Meilleur [EtatsDesVE EtatDu $Quoi] [EtatsDesVE EtatDu $Quoi2]]
	return [EtatsDesVE TaskDu $ME]
    }
    if {$Qui=="Meilleur"} {
	set I1 [lsearch -exact [EtatsDesVE LesEtatsUnis] $Quoi]
	set I2 [lsearch -exact [EtatsDesVE LesEtatsUnis] $Quoi2]
	if {$I1<$I2} { return $Quoi2 }
	return $Quoi
    }

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

    set LesEtats     [list Cloned Expression_tested Soluble Purified Crystallization Crystal Structure Stopped]
    set LesEtatsUnis [list Cloned Expression_tested Soluble Purified Crystallization Crystal Structure]    
    set LesTasks     [list Clon   Expr              Solu    Puri     InCr            Crys    PDB       STOP]
    set LesReverseEtats     [RetourneLaListe $LesEtats]
    set LesReverseEtatsUnis [RetourneLaListe $LesEtatsUnis]

    set EtatsDesVE(LesEtats)            $LesEtats
    set EtatsDesVE(LesEtatsUnis)        $LesEtatsUnis
    set EtatsDesVE(LesTasks)            $LesTasks
    set EtatsDesVE(LesReverseEtats)     $LesReverseEtats
    set EtatsDesVE(LesReverseEtatsUnis) $LesReverseEtatsUnis
    
    foreach Task $LesTasks Etat $LesEtats {
	set EtatsDesVE(EtatDu,$Task) $Etat
	set EtatsDesVE(TaskDu,$Etat) $Task
    }
    return [EtatsDesVE $Qui $Quoi $Quoi2]
}

proc MiseAJourSpineParVEDidier {} {
    set LesEtats            [EtatsDesVE "LesEtats"]
    set LesEtatsUnis        [EtatsDesVE "LesEtatsUnis"]
    set LesTasks            [EtatsDesVE "LesTasks"]
    set LesReverseEtats     [EtatsDesVE "LesReverseEtats"]
    set LesReverseEtatsUnis [EtatsDesVE "LesReverseEtatsUnis"]

    foreach Ligne [LesVEDidierCompatiblesGscope "GetList"] {
	set R1 ""
	scan $Ligne "%s %s %s %s" VE R1 pDEST PGS
	set R2 "${R1}_$pDEST"
	set R2 [Rec2 $R2 "R2"]
	set Alias [Alias $PGS]
	lappend LesPGS $PGS
	set TaskDidier "Sele"
	foreach Etat $LesReverseEtats {
	    if {[VEDidier $VE $Etat]!=1} { continue }
	    set TaskDidier [EtatsDesVE TaskDu $Etat]
	    lappend LesMeilleursEtatsDesVEsDuPGS($PGS,$Etat) $VE
	    break 
	}
#	Espionne "$VE $PGS $Alias $TaskDidier"	
    }
    set LesAnormaux {}
    set LesMeilleurs {}
    foreach PGS [lsort -unique $LesPGS] {
	foreach Etat $LesReverseEtatsUnis {
	    if { ! [info exists LesMeilleursEtatsDesVEsDuPGS($PGS,$Etat)]} { continue }
	    set Task [EtatsDesVE TaskDu $Etat]
	    set SpineTask [SpineTask $PGS]
	    set Best [EtatsDesVE MeilleurTask $SpineTask $Task]
	    if {$Task != $Best} {
		lappend LesAnormaux "\n\n$PGS [Alias $PGS ]\n\
			$LesMeilleursEtatsDesVEsDuPGS($PGS,$Etat)\n\
			SpineTask $SpineTask est meilleur que EtatDidier $Task"
	    }
	    lappend LesMeilleurs "$PGS [format "%-10s" [Alias $PGS]] $SpineTask $Task $LesMeilleursEtatsDesVEsDuPGS($PGS,$Etat)"
	    break
	}
    }
    AfficheListe $LesAnormaux "" LesAnormaux]
    return [AfficheListe $LesMeilleurs "" LesMeilleurs]
    exit
}

proc MutantsDeYann {} {
    foreach Ligne [LesLignesDuFichier "MutantsAFaire"] {
	if {$Ligne==""} { set Alias "" ; continue }
	scan $Ligne "%s" Mot
	if {$Alias==""} {
	    set Alias $Mot
	    set PGS [NomDuAlias $Alias]
	    set LesCodes {}
	    foreach Mutant [LesMutantsDe $PGS Names] {
		set InfoMute [ExtraitInfo $Mutant "Muted"]
		set LesMots [split $InfoMute " "]
		set Code [lindex $LesMots end]
		set AliasLu [lindex $LesMots end-1]
		if {$AliasLu==$Alias} {
		    lappend LesCodes $Code
		    set PGSDuCode($Code) $Mutant
		}
	    }
	    
	    continue
	}
	set Code $Mot
	if {[info exists PGSDuCode($Code)]} {
	    set Mut $PGSDuCode($Code)
	    Espionne "$Code $Mut [Alias $Mut] [ExtraitInfo $Mut Muted]"
	} else {
	    regsub {PGS0*} $PGS "" N
	    incr N 1000
	    while 1 {
		set Mut "PGS$N"
		if {[FileAbsent "[RepertoireDuGenome]/nuctfa/$Mut"] && ! [info exists EstNouveau($Mut)]} { break }
		incr N 300
	    }
	    set EstNouveau($Mut) 1
	    lappend AFaire "$PGS $Mut $Code"
	}
    }
    Espionne [SauveLesLignes $AFaire dans MutantsAFaire.lst]
}

proc LesOligosCommandes {} {
    
    FaireLire "Mise a jour de oligosMIEUX"

    foreach P [Oli "LaListeMerci"] {
	set Descr [Oli $P "Description"]
	if {[regexp "ignore"  $Descr]} { continue }
	if {[regexp "without" $Descr]} { continue }
	if {[regexp "mutant"  $Descr]} { continue }
	if {[regexp "MutOli"  $Descr]} { continue }
	if {[regexp "SeqOli"  $Descr]} { continue }
	set SEQ [string toupper [Oli $P "Seq"]]
	lappend OliDeLaSeq($SEQ) $P
    }

    foreach FOli [glob "[RepertoireDuGenome]/atelier/*/oligos_*.tfa"] {
	foreach Access [LaSequenceDuTFAs $FOli "LaListeDesAccess"] {
	    if {[regexp "^SeqOli" $Access]} {continue}
	    set LesLis [DecomposeLaLigne $Access]
	    set LesSujets [lindex $LesLis 0]
	    set LesAvs    [lindex $LesLis 1]
	    set LesAps    [lindex $LesLis 2]
	    if {$LesAvs==$LesAps} { FaireLire "$FOli\n$Access" }
	    if {$LesAps==""} {
		set Sens "5'"
		set Signaux [join $LesAvs "_"]
	    } else {
		set Sens "3'"
		set Signaux [join $LesAps "_"]
	    }
	    if {[llength $LesSujets]>1} { FaireLire "$FOli\ntrop de sujets" }
	    set Sujet [lindex $LesSujets 0]
	    set TFA [LaSequenceDuTFAs $FOli $Access]
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    set SEQ [string toupper $Seq]
	    set LesPs [list "PInconnu"]
	    if {[info exists OliDeLaSeq($SEQ)]} {
		set LesPs $OliDeLaSeq($SEQ)
	    } else {
		continue
		if {[OuiOuNon "$FOli\n$Access\n\nOn le traque ?"]} {
		    AfficheFichier $FOli "AvecRetour"
		}
		break
	    }
	    foreach P $LesPs {
		set Descr [Oli $P "Description"]
		set Cibles [StringSuivant " for " dans $Descr]
		set LesCibles [split $Cibles " "]
		set i [lsearch -exact $LesCibles $Sujet]
		if {[llength [lsort -unique $LesCibles]]<[llength $LesCibles]} {
		    FaireLire $Descr
		}
		if {$i<0} {
		    lappend LesCibles $Sujet
		    append Descr " $Sujet"
		    set NEW [SequenceFormatTFA [Oli $P "Seq"] $Descr]
		    Sauve $NEW dans "[RepertoireDuGenome]/oligosMIEUX/$P.tfa"
		    Espionne [format "%-17s %-20s %s %s=%s" $Sujet $Signaux $Sens $P $Descr]
		}
	    }
	}
    }
    exit
}

proc UrlCommandeOligo {} {
    return "http://wappli-igbmc.u-strasbg.fr:2030/oligcde"
}

proc WebOrder {{LesSeq {}} {LesNom {}} {LesNot {}}} {

    if {$LesSeq=={}} { set LesSeq "OligosKeeper" }
    while {$LesSeq=="OligosKeeper" } {
	if { ! [OuiOuNon "Do we use OligosKeeper ?"]} { return "" }
	FaireLire "Please choose the OligoKeeper.tfas"
	set FiSeq [ButineArborescence "All" "[RepertoireDuGenome]/atelier/OligosKeeper/*.tfas"]
	if {$FiSeq==""} { continue }
	regsub {.tfas$} $FiSeq "" FiNom
	regsub {.tfas$} $FiSeq "" FiNot
	append FiNom ".noms"
	append FiNot ".nots"
	set LesSeq [LesLignesDuFichier $FiSeq]
	set LesNom [LesLignesDuFichier $FiNom]
	set LesNot [LesLignesDuFichier $FiNot]
	return [WebOrder $LesSeq $LesNom $LesNot]
    }

    if {[OuiOuNon "OligosKeeper\n \
	    We could keep that oligo-order in a file and order all together ?"]} {
	set FiSeq ""
	if { ! [OuiOuNon "Do we create a new OligosKeeper ?" 1]} {
	    FaireLire "Please choose the OligoKeeper.tfas"
	    set FiSeq [ButineArborescence "All" "[RepertoireDuGenome]/atelier/OligosKeeper/*.tfas"]
	}
	while {$FiSeq==""} {
	    set FiSeq [FichierPourSaveAs "[RepertoireDuGenome]/atelier/OligosKeeper/OligosKeeper[Date].tfas"]
	    if {$FiSeq=="" && [OuiOuNon "Do I cancel OligosKeeper ?"]} { break }
	    if {$FiSeq==""} { continue }	    
	}
	regsub {.tfas$} $FiSeq "" FiNom
	regsub {.tfas$} $FiSeq "" FiNot
	append FiNom ".noms"
	append FiNot ".nots"
	foreach Seq $LesSeq Nom $LesNom Not $LesNot {
	    if {$Nom==""} { set Nom "NoValue" }
	    if {$Not==""} { set Not "NoValue" }
	    AppendAuFichier $FiSeq $Seq
	    AppendAuFichier $FiNom $Nom
	    AppendAuFichier $FiNot $Not
	}
	return $FiSeq
    }

    while 1 {
	set FichierForm "~/oligo.php.html"
	set LeTexte {}
	lappend LeTexte "Il faut maintenant se connecter sur le site de commande d'oligos"
	lappend LeTexte ""
	lappend LeTexte "[UrlCommandeOligo]/login.html"
	lappend LeTexte ""
	lappend LeTexte "Se loguer, et sauver le cadre de commande dans le fichier"
	lappend LeTexte "$FichierForm"
	lappend LeTexte ""
	lappend LeTexte "Valider cette page en selectionnant le nom du fichier ci-dessus."
	lappend LeTexte ""
	lappend LeTexte "  Merci."
	lappend LeTexte ""
	set Texte [join $LeTexte "\n"]
	set Retour [AfficheVariable $Texte "AvecRetour"]
	
	if {$Retour!=""} { break }
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }

    while 1 {
	set NewForm [MiseAJourFormulairePourMichel $FichierForm $LesSeq $LesNom $LesNot]
	set FichierNewForm [Sauve $NewForm dans $FichierForm.html]
	set LeTexte {}
	regsub {\~} $FichierNewForm "" FichierNewForm
	lappend LeTexte "Il faut maintenant recharger le fichier suivant dans le browser (Windows ou Linux)"
	lappend LeTexte " en corrigeant pour que le PC s'y retrouve"
	lappend LeTexte ""
	lappend LeTexte "file://h:$FichierNewForm"
	lappend LeTexte "file://[HomeRipp]/$FichierNewForm"
	lappend LeTexte ""
	lappend LeTexte "et valider cette page si tout se passe bien."
	lappend LeTexte ""
	lappend LeTexte "  Merci."
	lappend LeTexte ""
	set Texte [join $LeTexte "\n"]
	set Retour [AfficheVariable $Texte "AvecRetour"]
	
	if {$Retour!=""} { break }
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }
    return $Retour
}

proc MiseAJourFormulairePourMichel {FichierForm LesSeq LesNom LesNot} {
    set Formulaire [ContenuDuFichier $FichierForm]
    regsub -all -nocase "\"ctrloligo.php\"" $Formulaire "\"[UrlCommandeOligo]/ctrloligo.php\"" Formulaire
    regsub -all -nocase "\"oligcde.css\""   $Formulaire "\"[UrlCommandeOligo]/oligcde.css\""   Formulaire
    set iP 0
    foreach Seq $LesSeq Nom $LesNom Not $LesNot {
	set FORMULAIRE [string toupper $Formulaire]
	set iP [string first "NAME=\"PSEQ" $FORMULAIRE $iP]
	if {$iP<0} {
	    FaireLire "I did't find an available pseq in $FichierForm\nI'll break"
	    break
	}
	set iV [string first "VALUE=" $FORMULAIRE $iP]
	set iQuote [string first "\"" $FORMULAIRE $iV]
	set Formulaire [string replace $Formulaire $iQuote $iQuote "\"$Seq"]
	set FORMULAIRE [string toupper $Formulaire]

	set iP [string first "NAME=\"PNOM" $FORMULAIRE $iP]
	if {$iP<0} {
	    FaireLire "I did't find an available pnom in $FichierForm\nI'll break"
	    break
	}
	set iV [string first "VALUE=" $FORMULAIRE $iP]
	set iQuote [string first "\"" $FORMULAIRE $iV]
	set Formulaire [string replace $Formulaire $iQuote $iQuote "\"$Nom"]
	set FORMULAIRE [string toupper $Formulaire]

	set iP [string first "NAME=\"PEXP" $FORMULAIRE $iP]
	if {$iP<0} {
	    FaireLire "I did't find an available pexp in $FichierForm\nI'll break"
	    break
	}
	set iV [string first "VALUE=" $FORMULAIRE $iP]
	set iQuote [string first "\"" $FORMULAIRE $iV]
	set Formulaire [string replace $Formulaire $iQuote $iQuote "\"$Not"]
	set FORMULAIRE [string toupper $Formulaire]
    }
    return $Formulaire
}
 
proc LeDecompte {{Quoi ""}} {
    set LeDecompte {}
    set CumulMutants 0
    set CumulVPPCRs  0
    foreach Nom [ListeDesPABs] {
	set Alias [Alias $Nom]
	set LesMutants [LesMutantsDe $Nom]
	set NbMutants [llength $LesMutants]
	set LesVPPCRs [LesVirtualPPCRsDuPGS $Nom]
	foreach VPPCR $LesVPPCRs {
	    if {[info exists DejaVu($VPPCR)]} { continue }
	    incr CumulVPPCRs 
	}
	set NbVPPCRs [llength $LesVPPCRs]
	set SpineTask [SpineTask $Nom]
	set Owner [ExtraitInfo $Nom "Owner"]
	incr CumulMutants $NbMutants
	set Def [DefinitionRapide $Nom]
	lappend LeDecompte ""
	set Ligne [format "%8s %-15s %-4s %2d %2d %-30s %s" $Nom [string range $Alias 0 15] $SpineTask $NbMutants $NbVPPCRs $Owner $Def] 
	lappend LeDecompte $Ligne
	lappend LeDecompteDuOwner($Owner) $Ligne		
    }
    lappend LeDecompte ""
    lappend LeDecompte " $CumulMutants Sauvages et mutants"
    lappend LeDecompte " $CumulVPPCRs produits PCR"

    if {[regexp "ParOwner" $Quoi]} {
	regsub "ParOwner" $Quoi "" Quoi
	set LaPageOwner {}
	foreach Owner [lsort [array names LeDecompteDuOwner]] {
	    LConcat LaPageOwner $LeDecompteDuOwner($Owner)
	}
	set Decompte [join $LaPageOwner "\n"]
    } else {
	set Decompte [join $LeDecompte "\n"]
    }
    if {$Quoi=="GetText"} { return $Decompte }
    if {$Quoi=="Show"} { return [AfficheVariable $Decompte "" "XbgsSummary"] }
    return $LeDecompte
}

proc CorrigeLesBrocOlis {} {
#    if {[OuiOuNon "Attention il est dangereux de relancer CorrigeLesBrocOlis. STOP ?"]} { return "" }

    foreach N [VirtualPPCREnStock LaListeDesNs] {
	set P5 [VirtualPPCREnStock $N P5]
	if { ! [Oli $P5 "IsBrocOli"]} { continue }
	Espionne "[VirtualPPCREnStock $N]"
    } 

    foreach F [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $F]
	regsub ".tfa$" $P "" P
	set TFA [ContenuDuFichier $F]
	if {$TFA!=[Oli $P TFA]} { FaireLire "$TFA" }
	set Entete [EnteteDuTexteTFA $TFA]
	set Seq [QueLaSequenceDuTexteTFA $TFA]
	if { ! [regexp "BrocOli" $Entete]} { continue }
	set Full [StringApres "seeFull" dans $Entete]
	set EF [EnteteDuFichierTFA "[RepertoireDuGenome]/oligos/$Full.tfa"]
	set Broc [StringApres "seeBrocken" dans $EF]
	if {$Broc!=$P} { Espionne "$Entete\n$EF\n\n" }
	lappend LesB $P
    }
    AfficheListe $LesB "AvecOli" LesBrocOlis
    return 
    exit
    set DernierP 1120
    foreach F [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $F]
	regsub ".tfa$" $P "" P
	set TFA [ContenuDuFichier $F]
	set Entete [EnteteDuTexteTFA $TFA]
	set Seq [QueLaSequenceDuTexteTFA $TFA]
	if { ! [regexp "BrocOli" $Entete]} { continue }
	if {[regexp " replaces " $Entete]} { continue }
	if {[regexp " Rebuilded " $Entete]} { continue }
	regsub "/oligos/" $F "/oligos.20050930/" V
	if {[FileAbsent $V]} { FaireLire $V ; continue } 
	set VTFA [ContenuDuFichier $V]
	set VENT [EnteteDuTexteTFA $VTFA]
	set VSeq [QueLaSequenceDuTexteTFA $VTFA]
	set Coupe [StringApres "BrocOli with" dans $VENT]
	set Full [StringApres signal dans $Entete]
	regexp {_[^_]+$} $Coupe Ancre

	incr DernierP
	set NewP [format "P%4.4d" $DernierP]

	regsub "BrocOli with " $Entete "RebuildedBrockenOli of " NENT
	append NENT " seeBrocken $P"
	regsub {P[0-9]+ } $NENT "$NewP " NENT

	set BonVENT "$VENT replaces $Full seeFull $NewP"

	Espionne "\n\n$Entete\n$NENT\n$BonVENT"
	Espionne "$Seq\n$VSeq"
	Espionne "$Full $Coupe $Ancre"
	set Petit [SequenceFormatTFA $VSeq $BonVENT "nucbrut"]
	set Grand [SequenceFormatTFA $Seq  $NENT    "nucbrut"]
	
	Espionne "$Petit\n$Grand"
	Sauve $Petit dans "$F.new"
	Sauve $Grand dans "[RepertoireDuGenome]/oligos/$NewP.tfa.new"
	continue

	set Bon [string range $Entete 1 [incr I -1]]
	set New [SequenceFormatTFA $Seq $Bon "nucbrut"]
	Espionne "\n\n$TFA\n$New"
	Sauve $New dans $F
    }
    exit

    foreach P [Oli LaListeMerci] {
	set Entete [Oli $P Description]
	if { ! [regexp "BrocOli" $Entete]} { continue }
	Espionne $Entete
	set Signaux [Oli $P Signals]
	set Subjects [Oli $P Subjects]
	set Broc [lindex $Subjects end]
	set SeqO [Oli $P Seq]

	set LesBroc [split $Broc "_"]
	set LesCoupes [lrange $LesBroc 0 end-1]
	set LesSeqB {}
	foreach B $LesCoupes {
	    lappend LesSeqB [Signal $B]
	}
	set SeqB [join $LesSeqB ""]
	set SignauxCoupes [join $LesCoupes "_"]
	set BonneSeq "$SeqB$SeqO"

	set LesOlis [split $Signaux "_"]
	set LesBonsSignaux [concat $LesCoupes $LesOlis]
	set BonsSignaux [join $LesBonsSignaux "_"]
	regsub "with signal " $Entete "with signal ${SignauxCoupes}_" BonneEntete

	Espionne "$P $Signaux $Broc $BonsSignaux"	
	set BonTFA [SequenceFormatTFA $BonneSeq $BonneEntete "nucbrut"]
	Espionne [Sauve $BonTFA dans [FiSeqOl $P]]
    }
} 

proc SelectFromVEDidier {Clef ValeurVoulue {Op ""} {LesChamps ""} {Action ""}} {
    if {$Action==""} { set Action "Show" }
    if {$LesChamps==""} { set LesChamps [list "VE" "Ligne"] }
    if {$Op==""} { set Op "string equal -nocase"  }
    set LesLignes {}
    foreach VE [VEDidier ListeDes VE] {
	set Valeur [VEDidier $VE $Clef]
	if { ! [eval $Op \$Valeur \$ValeurVoulue]} { continue }
	set LaLigne {}
	foreach Champ $LesChamps {
	    lappend LaLigne [VEDidier $VE $Champ]
	}
	lappend LesLignes [join $LaLigne " "]
    }
    if {$Action=="GetList"} { return $LesLignes }
    if {$Action=="GetText"} { return [join $LesLignes "\n"] }
    set Titre "select [join $LesChamps "_"] where $Op $Clef $ValeurVoulue"
    return [AfficheVariable [join $LesLignes "\n"] "" $Titre]
}

proc LesClefsDeDidier {} {
    set LesClefs [list \
	    VE Cloned Expression_tested Soluble Insoluble Purified Crystallization Crystal Structure Stopped \
	    Coexpr_vector1 Coexpr_vector2 Coexpr_vector3 \
	    Scientist Vectorname Baculo Eukaryote \
	    DomainLimit Mutant ProtName CodeRipp Organism Comments]
}

proc LesEtatsDesVEs {} {
    return [list Cloned Expression_tested Soluble Insoluble Purified Crystallization Crystal Structure Stopped]
}

proc LeGrandResume {} {

    foreach Ligne [LesVEDidierCompatiblesGscope "GetList"] {
	set R1 ""
	scan $Ligne "%s %s %s %s" VE R1 pDEST PGS
	if {$R1==""} { continue }
	set R2 "${R1}_$pDEST"
	lappend LesVEDidierDuPGS($PGS) $VE
	set Rec2DuVEDidier($VE) $R2
    }
    SauveLesLignes [array get LesVEDidierDuPGS] dans "[Fiches]/VEDidierDuPGS.txt"

    set LesRapports {}
    set LesClefs [VEDidier ListeDes Clefs]
    foreach VE [VEDidier ListeDes VE] {
	set LaLigne {}

	set ProtName [VEDidier $VE "ProtName"]
	set Scientist [VEDidier $VE "Scientist"]
	set VectorName [VEDidier $VE "Vectorname"]
	set Organism    [VEDidier $VE "Organism"]

	set Alias $ProtName 
	set PGS [VEDidier $VE "CodeRipp"]
	if {$PGS==""} {
	    set PGS "------"
	} else {
	    set Alias [Alias $PGS]
	}

	lappend LaLigne $VE
	lappend LaLigne $PGS
	lappend LaLigne [format "%-10s" $ProtName]
	lappend LaLigne [format "%-10s" $Alias]
	lappend LaLigne [format "%-30s" $Scientist] 
	lappend LaLigne [format "%-15s" $VectorName]
	lappend LaLigne [format "%-15s" $Organism]
	if {[info exists Rec2DuVEDidier($VE)]} {
	    set R2 $Rec2DuVEDidier($VE)
	    set N [Rec1 $R2 N]
	    set Sujet [VirtualPPCREnStock $N Sujet]
	    set LesMots [split $Sujet "-"]
	    set F [lindex $LesMots end]
	    set D [lindex $LesMots end-1]

	    set pDONR [Rec1 $R2 Vecteur]
	    set pDEST [Rec2 $R2 Vecteur]
	    set P5 [VirtualPPCREnStock $N P5]
	    set P3 [VirtualPPCREnStock $N P3]
	    lappend LaLigne [format "%-25s" $R2]
	    lappend LaLigne "$P5 [Oli $P5 Signals]"
	    lappend LaLigne "$P3 [Oli $P3 Signals]"

	    set FichierRec2 [Rec2 $R2 Fichier]
	    set SeqRec2 [QueLaSequenceDuFichierTFA $FichierRec2]

	    set FichierFusionProt $FichierRec2
	    regsub "/rec2/"   $FichierFusionProt "/fusion/"     FichierFusionProt
	    regsub "/fusion/" $FichierFusionProt "/fusion/Fus_" FichierFusionProt
	    append FichierFusionProt ".prottfa"
	    if {[FileExists $FichierFusionProt]} {
		set SeqFusion [QueLaSequenceDuFichierTFA $FichierFusionProt]
	    } else {
		set SeqFusion ""
	    }
	    set LeTR {}
	    lappend LeTR VE           $VE
	    lappend LeTR ProteinName  $Alias
	    lappend LeTR Organism     $Organism
	    lappend LeTR Boundaries   "$D-$F"
	    lappend LeTR PGS          $PGS
	    lappend LeTR Rec2         $R2
#	    lappend LeTR OldProtname  $ProtName
#	    lappend LeTR Oligo5P      $P5
	    lappend LeTR Signals5     [Oli $P5 Signals]
	    lappend LeTR Signals3     [Oli $P3 Signals]

	    foreach Clef [LesEtatsDesVEs] {
		lappend LeTR $Clef [VEDidier $VE $Clef]
	    }
	    lappend LeTR NucSeqRec2   $SeqRec2
	    lappend LeTR ProtSequence $SeqFusion

	    set SeqProtCoupure ""
	    set Protease ""
	    foreach Signal [split [Oli $P5 Signals] "_"] {
		if {[EstUneProtease $Signal]} { set Protease $Signal ; break }
	    }
	    if {$Protease!=""} {
		set FichierCoupureProt $FichierRec2
		regsub "/rec2/"    $FichierCoupureProt "/coupure/"     FichierCoupureProt
		regsub "/coupure/" $FichierCoupureProt "/coupure/cut_" FichierCoupureProt
		append FichierCoupureProt "_$Protease.prottfa"
		if {[FileExists $FichierCoupureProt]} {
		    set SeqProtCoupure [QueLaSequenceDuFichierTFA $FichierCoupureProt]
		} else {
		    set SeqProtCoupure ""
		}
	    }
	    lappend LeTR ProtCutted   $SeqProtCoupure

	    set LesTitres {}
	    set LeRapport {}
	    foreach {T R} $LeTR {
		lappend LesTitres $T
		lappend LeRapport $R
	    }
	    if {$LesRapports=={}} {
		lappend LesRapports [join $LesTitres ";"]
	    }
	    set Rapport [join $LeRapport ";"]
	    lappend LesRapports $Rapport
	}
	set Ligne [join $LaLigne "\t"]
	lappend LeGrandResume $Ligne
    }
    SauveLesLignes $LesRapports dans "[Fiches]/ReportForJaime.txt"
    set Resume [join $LeGrandResume "\n"]
    return [AfficheVariable $Resume]
}

proc ShowCorrespondingFile Selection {
    scan $Selection "%s" PRRF
    if {[regexp "^Fus_" $PRRF]} {
	foreach Fichier [glob "[RepertoireDuGenome]/fusion/$PRRF*"] {
	    AfficheFichier $Fichier "avecFormate"
	    return 
	}
    }
    set Type [regexp -all "_" $PRRF]
    if {$Type==0} { return [AfficheFichier "[RepertoireDuGenome]/ppcr_virtuels/$PRRF"] }
    if {$Type==1} { return [AfficheFichier "[RepertoireDuGenome]/rec1/$PRRF"] }
    if {$Type==2} { return [AfficheFichier "[RepertoireDuGenome]/rec2/$PRRF"] }
    return ""
}

proc QuelleCoupurePourTous {} {
    foreach R2 [Rec2 LaListeDes Rec2] {
	Espionne "$R2 [QuelleCoupure $R2]"
    }
}

proc QuelleCoupure R2 {
    set N [Rec1 $R2 N]
    set P5 [VirtualPPCREnStock $N P5]
    set Signaux [Oli $P5 Signals]
    set LesSignaux [split $Signaux "_"]
    set Enzyme ""
    foreach Signal $LesSignaux {
	set Pos  [CoupureParEnzyme $Signal position]
	set Type [CoupureParEnzyme $Signal type]
	if {$Pos!=""} { set Enzyme $Signal ; set Position $Pos ; break }
    }
    if {$Enzyme==""} { return "" }
    return "$Enzyme $Position $Type"
}

proc Fusion5P {{Qui ""} {Quoi ""}} {
    global Fusion5P

    if {$Qui==""} {
	set Qui "LaListeDes"
	set Quoi "Fusions"
    }

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

    if {$Quoi=="Sequence"} {
	set Fichier [Fusion5P $Qui "Fichier"]
	if {$Fichier==""} { return "" }
	return [QueLaSequenceDuFichierTFA $Fichier]
    }

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

    set FichierFusion5P "[RepertoireDuGenome]/fiches/fusion"

    set Fusion5P("EstCharge") ""
    if {[file exists $FichierFusion5P]} {
	array set Fusion5P [LesLignesDuFichier $FichierFusion5P]
	return [Fusion5P $Qui $Quoi]
    }

    set Fusion5P(LaListeDes,Fichiers) {}
    set Fusion5P(LaListeDes,Fusions) {}
    foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/fusion/*"] {
	set Queue [file tail $Fichier]
	set Entete [EnteteDuFichierTFA $Fichier]
	if {$Entete==""} { continue }
	set Fus [EnteteDuFichierTFA $Fichier "access"]

	regsub "Fus_" $Fus "" R2
	set Fusion5P($Fus,Rec2) $R2

	lappend Fusion5P(LaListeDes,Fichiers) $Fichier
	lappend Fusion5P(LaListeDes,Fusions)   $Fus
    }
    set Fusion5P(LaListeDes,Fichiers) [lsort [set Fusion5P(LaListeDes,Fichiers)]]
    set Fusion5P(LaListeDes,Fusions)  [lsort [set Fusion5P(LaListeDes,Fusions)]]
    SauveLesLignes [array get Fusion5P] dans $FichierFusion5P
    return [Fusion5P $Qui $Quoi]
}

proc VerifieLesRec2 {} {
    foreach R [glob "[RepertoireDuGenome]/rec2Oublies/*"] {
	set Queue [file tail $R]
	regsub {\.tfa$} $Queue "" R2
	set D "[RepertoireDuGenome]/rec2/$R2"
	if {[FileExists $D]} { continue }
	regexp {N[0-9]+} $R2 N
	lappend LesOublies "$N $R"
    }
    AfficheVariable [join $LesOublies "\n"] AvecVirtualPPCR "LesOublies"
    return
    set LesCorrectifs {} 
    foreach D [glob "[RepertoireDuGenome]/rec2/*"] {
	set R2 [file tail $D]
	set R "[RepertoireDuGenome]/rec2Oublies/$R2"
	if {[FileAbsent $R]} {
	    set R "$R.tfa"
	    if {[FileAbsent $R]} { continue }
	}
	if {[ContenuDuFichier $D]==[ContenuDuFichier $R]} { Espionne "ok $D" ; continue }
	set SR [QueLaSequenceDuFichierTFA $R]
	set SD [QueLaSequenceDuFichierTFA $D]
	set ER [EnteteDuFichierTFA $R]
	set ED [EnteteDuFichierTFA $D]
	if { ! [string equal -nocase $SR $SD]} { FaireLire "les sequences different\n$ER\n$ED" ; continue }
	set OldER $ER
	if {[regexp -nocase "ppcr PGS" $ER]} { regsub -nocase "ppcr PGS" $ER "Ppcr for PGS" ER }
	if {$ER==$ED} { lappend LesCorrectifs "il faut corriger $OldER" ; continue }
	if {[string first " Rec2 " $ER]!=[set L [string last " Rec2 " $ER]]} {
	    set ER [string range $ER 0 [incr L -1]]
	}
	if {$ER==$ED} { lappend LesCorrectifs "il enlecer le second Rec2 dans $OldER" ; continue }
	set Mouchard ""
	foreach X [split $ER ""] Y [split $ED ""] {
	    if {$X==$Y} { set M " " } else { set M "^" }
	    append Mouchard $M
	}
	AfficheVariable "\n$ER<\n$ED<\n$Mouchard<" AvecRetour
    }
    AfficheVariable [join $LesCorrectifs "\n"]

}

proc CreeLesFichiersExtension5PrimeDeRec2PourTous {} {
    foreach FichierRec2 [Rec2 LaListeDes Fichiers] {
	set FiFuNP [CreeLesFichiersExtension5PrimeDeRec2 $FichierRec2]
	if {$FiFuNP!=""} {
	    scan $FiFuNP "%s" FiFuN
	    lappend LesFiFuN $FiFuN
	}
    }
    return $LesFiFuN
}

proc ShowLesVEDidierDuPGS PGS {
    set LesVE []
}

proc VEDidier {{Qui ""} {Quoi ""}} {
    global VEDidier

    if {$Qui==""} { set Qui "ListeDes" }
    if {$Quoi==""} {
	if {$Qui=="ListeDes"} {
	    set Quoi "VE"
	} else { 
	    set Quoi "Ligne"
	}
    } 

    if {$Qui=="Show" && $Quoi=="All"} { return [VEDidier "All" "Show"] }
    if {$Quoi=="Show"} {
	set VEs $Qui
	if {$Qui=="All"} { set VEs [join [lsort [VEDidier ListeDes VE]] " "] }
	set LaPage {}
	foreach Mot [LesMotsDeLaLigne $VEs] {
	    if { ! [regexp {^VE[0-9]+$} $Mot]} { continue }
	    lappend LaPage [VEDidier $Mot Ligne]
	}
	return [AfficheListe $LaPage "AvecOligo" $Qui]
    }

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

    set Texte [HttpGetTextFromUrl "http://tursan/vestatus/vecsvcrlf.php"]
    set DejaVuEntete 0
    foreach Ligne [split $Texte "\n"] {
	if { ! [regexp "^VE" $Ligne]} {continue}
	set Ligne [string trim $Ligne ";"]
	set LesMots [split $Ligne ";"]
	if {! $DejaVuEntete} {
	    set LesClefs $LesMots
	    set VEDidier(ListeDes,Clefs) $LesClefs
	    set DejaVuEntete 1
	    continue
	}
	set VE [lindex $LesMots 0]
	if {[info exists VEDidier($VE,Ligne)]} { continue }
	lappend VEDidier(ListeDes,VE) $VE
	set VEDidier($VE,Ligne) $Ligne
	foreach Mot $LesMots Clef $LesClefs {
	    set VEDidier($VE,$Clef) $Mot
	}
    }
    set VEDidier("EstCharge") 1
    return [VEDidier $Qui $Quoi]
}

proc AllAboutVE {} {
    FaireLire "Je ne sais pas ce que fait AllAboutVE ..."
    set LesLignes [list "VE\tProtein\tVector\tStart\tEnd\tPGS\tRec2\tDescription"]
    foreach VE [VE ListOf VE] {
	set Proteine [VE $VE "Protein"]
	set Vecteur [VE $VE "Vector"]
	set Bornes [VE $VE "Domain_Boundaries"]
	set Debut 1
	set Fin "98765"
	regsub "/" $Bornes " " Bornes
	scan $Bornes "%d %d" Debut Fin
	set Nom [NomDuAlias $Proteine]
	if {$Nom==""} { continue }
	Espionne "$Proteine $Nom"
	set Trouve 0
	foreach R2 [Rec2 $Nom LesRec2] {
	    set V2 [Rec2 $R2 Vecteur]
	    set Descr [Rec2 $R2 Description]
	    set PDF [StringApres " Ppcr for $Nom " dans $Descr]
	    set LesPDF [split $PDF "-"]
	    set D [lindex $LesPDF end-1]
	    set F [lindex $LesPDF end]
	    regsub -- "\\-$D\\-$F$" $PDF "" P
	    regsub ".$" $P "" P
	    if {[string equal -nocase $P $Proteine] && $D==$Debut && $F==$Fin} {
		set Trouve 1
		break
	    }
	}
	if { ! $Trouve} { continue }
	set Ligne "$VE\t$P\t$Vecteur\t$Debut\t$Fin\t$Nom\t$R2\t$Descr"
	lappend LesLignes $Ligne
    }
    return [SauveLesLignes $LesLignes dans "[RepertoireDuGenome]/fiches/AllAboutVE.csv"]
}

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

proc VeFromSbgpDatabase {{V ""} {P ""} {S ""}} {
    global VE
    set GetFirst 1
    if {$V=="" && $P=="" && $S==""} {
	set GetFirst 0
	set V "%"
    }

    set SiteVe "http://130.79.76.61/TREX/steroids/steroids_list/Cloning/cloning_list/Vetxt.php"
    set Url $SiteVe
    append Url "?ve="
    append Url $V
    append Url "&protein="
    append Url $P
    append Url "&scientist="
    append Url $S

    set LesLignes {}
    HttpCopy $Url LesLignes
    if {$LesLignes=={}} { return "" }
    set Entete [lindex $LesLignes 0]
    set LesLignes [lrange $LesLignes 1 end]
    if {$Entete==""} {
	set Entete [lindex $LesLignes 0]
	set LesLignes [lrange $LesLignes 1 end]
    }

    if {$GetFirst} { return [lindex $LesLignes 0] }

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

    set Precedent ""
    foreach NomCol [split $Entete ";"] {
	regsub -all "#" $NomCol "" NomCol
	set NomCol [string trim $NomCol]
	regsub -all " " $NomCol "_" NomCol
	if {$NomCol==""} { set NomCol "${Precedent}_2" }
	lappend LesNomsCols $NomCol 
    }
    set VE(ListOf,Columns) $LesNomsCols
    set NLig 0
    foreach Ligne $LesLignes {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	incr NLig
	set LesVals [split $Ligne ";"]  
	foreach NomCol $LesNomsCols Val $LesVals {
	    if {$NomCol=="VE"} {
		set ValVE $Val
		set VE($ValVE,Line)   $Ligne
		lappend VE(ListOf,VE) $ValVE
	    }
	    set VE($NLig,$NomCol)  $Val
	    set VE($ValVE,$NomCol) $Val
	}
	
    }
    return $NLig
}

proc VectorsRecuDeDidier {} {
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/vecteurs/VectorsRecuDeDidier.txt"] {
	if {[regexp ">" $Ligne]} {
	    scan $Ligne "%s" Access
	    regsub ">" $Access "" Access
	    if {[info exists Seq($Access)]} { FaireLire "dejavu $access" }
	    set Seq($Access) ""
	    lappend LesAccess $Access
	} else {
	    set Ligne [string toupper $Ligne]
	    if {[regexp -nocase {[^atgc]} $Ligne]} { FaireLire $Ligne }
	    append Seq($Access) $Ligne
	}
    }
    foreach Access $LesAccess {
	set ADN $Seq($Access)
	set F [FindVector $Access]
	if {$F!=""} {
	    set Moi [QueLaSequenceDuFichierTFA $F]
	    if { ! [string equal -nocase $ADN $Moi]} {
		VoisinADN ">[file tail $F]\n$ADN\n>Moi\n$Moi"
		AfficheVariable "$F" "AvecRetour"
	    }
	    continue
	}
	set L [string length $ADN]
	set TFA [SequenceFormatTFA $ADN "$Access cloning vector $L bp. (from Didier)"]
	Sauve $TFA dans "[RepertoireDuGenome]/vecteurs/pDEST/$Access.tfa"
	Espionne "$Access $L"
    }
}

proc FindVector V {
    global FindVector
    set V [string toupper $V]
    if {[info exists FindVector($V)]} { return $FindVector($V) }
    if {[info exists FindVector("EstCharge")]} { return "" }
    
    foreach File [LesVecteurs] {
	set Vec [file tail $File]
	regsub {\..*} $Vec "" Vec
	set VEC [string toupper $Vec]
	set FindVector($Vec) $File
	set FindVector($VEC) $File
	set FindVector(NAMEOF_$Vec) $Vec 
	set FindVector(NAMEOF_$VEC) $Vec 
    }
    set FindVector("EstCharge") 1
    return [FindVector $V]
}


proc LesVEDidierCompatiblesGscope {{Action ""}} {

    if {$Action==""} { set Action "ShowOnly" }

    set FichierVEDidierCompatiblesGscope "[Fiches]/VEDidierCompatiblesGscope.txt"
    if {$Action=="GetList" && [FileExists $FichierVEDidierCompatiblesGscope]} {
	return [LesLignesDuFichier $FichierVEDidierCompatiblesGscope]
    }
    set LesNonPGS {}
    set LesNonCodeRipp {}
    set LesNonGateway {}
    set LesVecteursManquants {}
    set LesMauvaisesLimites {}
    set LesMauvaisProtName {}
    foreach VE [VEDidier ListeDes VE] {
	set ProtName    [VEDidier $VE "ProtName"]
	set Scientist   [VEDidier $VE "Scientist"]
	set Vectorname  [VEDidier $VE "Vectorname"]
	set DomainLimit [string trim [VEDidier $VE "DomainLimit"]]
	set CodeRipp    [VEDidier $VE "CodeRipp"]
	if {$CodeRipp==""} {
	    lappend LesNonCodeRipp "$VE [VEDidier $VE Ligne]"
	    continue
	}

	set NomDuProtName [NomDuAlias $ProtName]
	if {$NomDuProtName=="" && $CodeRipp!=""} {
	    set BetterProtName [Alias $CodeRipp]
	    if {0 && [OuiOuNon "the ProtName from Didier '$ProtName' \
		    doesn't correspond to the Gscope ProtName '$BetterProtName' \n\
		    Do I use $BetterProtName"]} {
		set ProtName $BetterProtName
	    }
	    lappend LesMauvaisProtName "'$ProtName' '$BetterProtName' $CodeRipp $Scientist"
	} 

	set Organism    [VEDidier $VE "Organism"]
	set ProtOrga "${ProtName}_$Organism"
	regsub -all " " $ProtOrga "_" ProtOrga
	if {[NomDuAlias $ProtName]!=""} {
	    	set AliasGscope $ProtName
	} else {
	    set AliasGscope [AliasAlias $ProtOrga "Gscope"]
	}
	set Comments    [VEDidier $VE "Comments"]
	set PGS ""
	set DE ""
	if {$AliasGscope!=""} {
	    set PGS [NomDuAlias $AliasGscope]
	    if {[regexp " " $PGS]} {
		scan $PGS "%s %s" PGS PGS2
		if {$CodeRipp==$PGS2} { set PGS $PGS2 }
	    }
	    set DE [DefinitionRapide $PGS]
	}
	if {$PGS==""} {
	    lappend LesNonPGS "$VE [VEDidier $VE Ligne]"
	    continue
	}
	if {$CodeRipp!="" && $CodeRipp!=$PGS} {
	    FaireLire "CodeRipp is not PGS\n[VEDidier $VE Ligne]\n $AliasGscope $PGS"
	}
	regsub "/" $DomainLimit " " Limites
	scan $Limites "%d %d" D F
	
	if {! [info exists Missing($Vectorname)]} {
	    set Trouve [FindVector $Vectorname]
	    if {$Trouve==""} {
		Espionne "missing vector $Vectorname for $VE $PGS $AliasGscope $D $F $Scientist"
		lappend LesVecteursManquants $Vectorname
		set Missing($Vectorname) 1
		continue
	    }
	}

	set LesVPs [LesVirtualPPCRsDuPGS $PGS]
	set Ok 0
	set LesMauvaisSujets {}
	foreach N $LesVPs {
	    set Sujet [VirtualPPCREnStock $N "Sujet"]
	    if { ! [regexp {[0-9]+\-[0-9]+$} $Sujet] } {
		lappend LesMauvaisSujets "$N $Sujet"
		continue
	    }
	    Espionne [VirtualPPCREnStock $N "Resume"]
	    regsub -all -- {\-} $Sujet " " Mots
	    set LesMots [split $Mots " "]
	    set Ds [lindex $LesMots end-1]
	    set Fs [lindex $LesMots end]
	    regsub -- "\-$D\-$F$" $Sujet "" PName
	    set Dp $D
	    set Fp $F
	    if {$Ds==2 && $Dp==1} { set Dp 2 }
	    if {$Ds==2 && $Dp==3} { set Dp 2 }
	    if {[expr abs($Fs-$Fp)<=1]} { set Fp $Fs }
	    if {$Dp==$Ds && $Fp==$Fs} { set Ok 1 ; break }
	    lappend LesMauvaisSujets "$N $Sujet"
	}
	if {$Ok} {
	    if {$Dp!=$D || $Fp!=$F} {
		lappend LesMauvaisesLimites "$VE $ProtName $D>$Dp $F>$Fp [VirtualPPCREnStock $N]"
	    }  
	    set Vecteur [FindVector NameOf_$Vectorname]
	    set R1 "${N}_pDONR207"
	    set NduR [Rec1 $R1 N]
	    if {$NduR!=$N} {
		lappend LesNonGateway "$N n'a pas de Rec1 $VE [VEDidier $VE Ligne]"
		continue
	    }
	    set Type [TypeDeVecteurGateway $Vecteur]
	    if {$Type!=2} {
		lappend LesNonGateway "$N son $Vectorname n'est pas Gateway $VE [VEDidier $VE Ligne]"
		continue
	    }
	    lappend LaSortie "$VE $R1 $Vecteur $PGS $AliasGscope $D $F $Vectorname $Scientist [VirtualPPCREnStock $N]"  
	} else {
	    lappend LesMauvais "nothing for $VE $PGS $AliasGscope $D $F $Vectorname $Scientist"
	    lappend LesMauvais [join $LesMauvaisSujets "\n"]
	    lappend LesMauvais ""
	}
    }
    set LaSortie [lsort $LaSortie]
    if {$LesNonCodeRipp!={}} {
	Espionne [SauveLesLignes $LesNonCodeRipp dans "[Fiches]/NonCodeRipp.txt"]
    }
    if {$LesNonPGS!={}} {
	Espionne [SauveLesLignes $LesNonPGS dans "[Fiches]/NonPGS.txt"]
    }
    if {$Action!="ShowOnly"} { 
	if {$LesNonPGS!={}} {
	    Espionne [SauveLesLignes $LesNonPGS dans "[Fiches]/NonPGS.txt"]
	}
	if {$LesMauvaisProtName!={}} {
	    Espionne [SauveLesLignes $LesMauvaisProtName dans "[Fiches]/MauvaisProtName.txt"]
	}
	if {$LesMauvaisesLimites!={}} {
	    Espionne [SauveLesLignes $LesMauvaisesLimites dans "[Fiches]/MauvaisesLimites.txt"]
	}
	if {$LesNonGateway!={}} {
	    Espionne [SauveLesLignes $LesNonGateway dans "[Fiches]/NonGateway.txt"]
	}
	if {$LesVecteursManquants!={}} {
	    set LesVecteursManquants [lsort -unique $LesVecteursManquants]
	    Espionne [SauveLesLignes $LesVecteursManquants dans "[Fiches]/VecteursManquants.txt"]
	}
	SauveLesLignes $LaSortie dans $FichierVEDidierCompatiblesGscope
    }
    if {$Action=="GetList"} { return $LaSortie }
    AfficheVariable [join $LesMauvais "\n"]
    return [AfficheVariable [join $LaSortie "\n"]]
}

proc LesScientistsDeDidier {} {
    foreach VE [VEDidier ListeDes VE] {
	set S [VEDidier $VE Scientist]
	if { ! [info exists NbVE($S)]} {set NbVE($S) 0 }
	incr NbVE($S)
    }
    set LesScientists [lsort [array names NbVE]]
    return $LesScientists
}

proc ShowVEDidier args {

    set Titre [join $args "_"]
    regsub -all " " $Titre "_" Titre

    set Collapse ""
    if {[llength $args]%2==1} {
	set Collapse [lindex $args end]
	set args [lrange $args 0 end-1]
    }

    set Collapse [string equal -nocase $Collapse "Collapse"]
    set LesLignes {}
    set LesNouveaux {}
    foreach VE [VEDidier ListeDes VE] {
	set ProtName    [VEDidier $VE "ProtName"]
	set Scientist   [VEDidier $VE "Scientist"]
	set Vectorname  [VEDidier $VE "Vectorname"]
	set Organism    [VEDidier $VE "Organism"]
	set DomainLimit [string trim [VEDidier $VE "DomainLimit"]]
	set CodeRipp    [VEDidier $VE "CodeRipp"]
	set ProtOrga "${ProtName}_$Organism"
	regsub -all " " $ProtOrga "_" ProtOrga
	set AliasGscope [AliasAlias $ProtOrga "Gscope"]
	set Comments    [VEDidier $VE "Comments"]
	if {$AliasGscope==""} { set AliasGscope "-" }
	if {$CodeRipp==""}    { set CodeRipp "-" }
	set Ok 1
	foreach {C V} $args {
	    if {$V=="NotEmpty"} {
		if {[set $C]==""} { set Ok 0 ; break }
		continue
	    }
	    if { ! [string equal [set $C] $V] } { set Ok 0 ; break }
	}
	if { ! $Ok } { continue }
	if {$Collapse && [info exists DejaVu($ProtOrga)]} { continue }


	set PGS ""
	set DE ""
	if {$AliasGscope!="-"} {
	    set PGS [NomDuAlias $AliasGscope]
	    set DE [DefinitionRapide $PGS]
	}
	if {$PGS!=""} { lappend LesNouveaux "$ProtName;$Organism;$PGS;$AliasGscope;$DE" }
	set DejaVu($ProtOrga) 1
	lappend LesLignes "$VE $ProtName $Organism $AliasGscope $Vectorname $Scientist $DomainLimit $CodeRipp $PGS $Organism $Comments $DE"
    }
    SauveLesLignes $LesNouveaux dans "[Fiches]/NouveauCodeRipp.txt"
    return [AfficheVariable [join $LesLignes "\n"] "" $Titre]

}


proc AliasManquants {} {
    foreach VE [VEDidier ListeDes VE] {
	set D [VEDidier $VE "ProtName"]
	set O [VEDidier $VE "Organism"]
	set DO "$D$O"
	regsub -all " " $DO "_" DO
	set VEDuAlias($DO) $VE
    }

    foreach D [AliasAlias ListeDes Didier] {
	set G [AliasAlias $D Gscope]
	if {[AliasAlias $D Gscope]!=""} { continue }
	set Scientist "Scientist unknown" 
	if {[info exists VEDuAlias($D)]} {
	    set VE $VEDuAlias($D)
	    set Scientist [VEDidier $VE Scientist]
	}
	Espionne "$D $Scientist"
    }
    exit
}

proc AliasAlias {A {Lequel ""} {Append ""}} {
    global AliasAlias

    if {$Append==""} { set Append "NoAppend" }
    set Append [string equal -nocase $Append "Append"]

    if {$Lequel==""} { set Lequel "Gscope" }

    if {[info exists AliasAlias($A,$Lequel)]} { return $AliasAlias($A,$Lequel) }
    if {[info exists AliasAlias("EstCharge")]} { return "" }

    set LesAliasGscope [lsort -dictionary [LesAliasExistants]]
    set FichierAliasAlias "[RepertoireDuGenome]/fiches/AliasAlias"
    if {[FileExists $FichierAliasAlias]} {
	array set AliasAlias [LesLignesDuFichier $FichierAliasAlias]
    }
    set AliasAlias("EstCharge") 1
    if { ! $Append } { return [AliasAlias $A $Lequel] }

    foreach VE [VEDidier ListeDes VE] {
	Espionne $VE
	set ProtName [VEDidier $VE ProtName]
	set Organism [VEDidier $VE Organism]
	set Original $ProtName
	set ProtName [string trim $ProtName]
	regsub { [^ ]$} $ProtName "" ProtName
	set ProtOrga "${ProtName}_$Organism"
	regsub -all " " $ProtOrga "_" ProtOrga
	if {[info exists AliasAlias($ProtOrga,Gscope)]} { continue }
	Espionne "$ProtOrga"
	set LesAliasLesPlusProches [LesAliasLesPlusProches $ProtOrga]
	if {0 && [string equal $ProtName [lindex $LesAliasLesPlusProches 0]]} {
	    set AliasAlias($ProtOrga,Gscope) $AliasGscope
	    set AliasAlias($AliasGscope,Didier) $ProtOrga
	    continue
	}
	set Ligne [VEDidier $VE]
	while 1 {
	    set Meilleur [ChoixParmi [concat [list SaveAndQuit $ProtOrga $Ligne "****"] \
		    $LesAliasLesPlusProches [list "******"] $LesAliasGscope]]
	    if {[regexp "SaveAndQuit" $Meilleur]} {
		if {[OuiOuNon "Do I save and quit ?"]} { break }
		continue
	    }
	    break
	}
	if {[regexp "SaveAndQuit" $Meilleur]} { break }
	set AliasAlias($ProtOrga,Gscope) $Meilleur
	set AliasAlias($Meilleur,Didier) $ProtOrga
    }
    foreach {C V} [array get AliasAlias] {
	ScanLaListe [split $C ","] POA Qui
	if {$Qui=="Gscope"} { lappend LesDidier $POA }
	if {$Qui=="Didier"} { lappend LesGscope $POA }
    }
    set AliasAlias(ListeDes,Gscope) [lsort $LesGscope]
    set AliasAlias(ListeDes,Didier) [lsort $LesDidier]

    SauveLesLignes [array get AliasAlias] dans $FichierAliasAlias
    return [AliasAlias $A $Lequel]
}

proc LesAliasLesPlusProches A {
    set Orga ""
    regexp {_([^_]+_[^_]+)$} $A Match Orga
    regsub -all "_" $Orga " " Orga

    regsub {_[^_]+_[^_]+$} $A "" A

    foreach Alias [LesAliasExistants] {
	set Existe($Alias) 1
    }

    set Genre "XXXXXXXXX"
    set Espece "XXXXXXXXX"
    scan $Orga "%s %s" Genre Espece
    set G [string index $Genre 0]
    set E [string index $Espece 0]
    set Ge "$G$E"
    set ge [string tolower $Ge]
    set LesPossibles {}
    foreach Alias [LesAliasExistants] {
	if {[string equal $A $Alias]} {
	    set PGS [NomDuAlias $Alias]
	    set Organisme [OrganismeDuPAB $PGS]
	    set O ""
	    regexp {<<(.+)>>} $Organisme Match O
	    Espionne "$PGS $Organisme $O $Orga"
	    if {$O!=$Orga} { break }
	    lappend LesPossibles $Alias
	}
    }

    set X $A
    regsub -all {[\-\_]} $X "" X
    regsub -nocase "alpha" $X "a" X
    regsub -nocase "beta"  $X "b" X
    regsub -nocase "gamma" $X "g" X
    foreach Alias [LesAliasExistants] {
	set Y $Alias
	regsub -all {[\-\_]} $Y "" Y
	if {[string equal -nocase $X $Y]} {
	    set PGS [NomDuAlias $Alias]
	    set Organisme [OrganismeDuPAB $PGS]
	    regexp {<<(.+)>>} $Organisme Match O
	    if {$O!=$Orga} { continue }
	    lappend LesPossibles $Alias
	}
    }
    foreach Possible [list "$Ge$A" "$ge$A" "$A$Ge" "$A$ge"] {
	if {[info exists Existe($Possible)]} { lappend LesPossibles $Possible } 
    }
    return $LesPossibles
}

proc RetrouveLesVEsDeDidier {} {
    foreach VE [VEDidier ListeDes VE] {
	set ProtName [VEDidier $VE ProtName]
	set ProtName [string trim $ProtName]
	regsub { [^ ]$} $ProtName "" ProtName
	set CodeRipp [VEDidier $VE CodeRipp]
	set Alias [AliasAlias $ProtName Gscope]
	set PGS [NomDuAlias $Alias]
	if {$PGS!=""} {
	    continue
	}
	Espionne [VEDidier $VE]
	Espionne "$VE $ProtName <Alias:$Alias> <PGS:$PGS> <CodeRipp:$CodeRipp>"
    }
    exit
}

proc NKI {} {
    global NKI
    foreach Fichier [lsort [glob "[HomeRipp]/cgi*.htm"]] {
	set Texte [ContenuDuFichier $Fichier]
	while 1 {
	    set Texte [StringSuivant "top.iwp.editRecById" dans $Texte]
	    if {$Texte==""} { break}
	    regsub {><span[^>]+>} $Texte "" Texte
	    regexp {[^<]+} $Texte IndicesValeur
	    set Valeur [StringSuivant "\"" dans $IndicesValeur]
	    regsub -all {[^0-9]} $IndicesValeur " " Indices
	    scan $Indices "%d %d %d %d" P C B L
 	    lappend NKI(LesPages) $P
	    set NKI($P,$L,$C) $Valeur
	    lappend NKI($P,LesLignes) $L
	    lappend NKI($P,$L,LesColonnes) $C
	}
    }

    set LesEntetesPourXls [list \
	    Page Line \
	    TargetsTried Constructs Trials Soluble Crystals NMR Diffraction Lead Complex Status \
	    TargetsChoosen ExpressionSystem TargetFamily Group]
    set LeXls [list [join $LesEntetesPourXls "\t"]]

    set OldGroupe ""
    foreach P [lsort -integer -unique $NKI(LesPages)] {
	foreach L [lsort -integer -unique $NKI($P,LesLignes)] {
	    if {$L==0} {
		set Groupe $NKI($P,0,41)
		set Famille $NKI($P,0,42)
		set NbTargets $NKI($P,0,43)
		continue
	    }
	    set Ligne "$P $L"
	    set LesValeurs {}
	    set LesValeursPourXls [list $P $L]
	    set i 0
	    foreach C [lsort -integer -unique $NKI($P,$L,LesColonnes)] {
		if {$C==44} { set Systeme $NKI($P,$L,$C) ; continue }
		set V $NKI($P,$L,$C)
		lappend LesValeursPourXls $V
		if {[regexp {^[0-9]+$} $V]} {
		    set NC 4
		    if {[incr i] > 4} { set NC 2 } 
		    set V [format "%${NC}d" $NKI($P,$L,$C)]
		} else {
		    if {$V=="In progress"} { set V "+" } else { set V "/" }
		}
		if {$C==45} { set V "$V/[format "%3d" $NbTargets]" } 
		lappend LesValeurs $V
	    }
	    if {$Groupe!=$OldGroupe} { Espionne "\n$Groupe" }
	    set OldGroupe $Groupe
	    Espionne "[format "%3d" $P] $L [join $LesValeurs " "] [format "%-35s" $Systeme]  $Famille"
	    lappend LesValeursPourXls $NbTargets $Systeme $Famille $Groupe
	    lappend LeXls [join $LesValeursPourXls "\t"]
	}
	SauveLesLignes $LeXls dans "[HomeRipp]/NKIPourXls.txt"
    }
    exit
}

proc MergeOligosKeepers {{LesKeepers ""} {FiSeq ""}} {
    while {$LesKeepers==""} {
	set LesKeepers [MorceauxChoisis \
		[lsort [glob -nocomplain "[RepertoireDuGenome]/atelier/OligosKeeper/*.tfas"]]]
	if {$LesKeepers!=""} {break}
	if {[OuiOuNon "Do we cancel ?"]} { return "" }
    }
    while {$FiSeq==""} {
	set FiSeq [FichierPourSaveAs "[RepertoireDuGenome]/atelier/OligosKeeper/OligosKeeper[Date].tfas"]
	if {$FiSeq=="" && [OuiOuNon "Do I cancel OligosKeeper ?"]} { break }
	if {$FiSeq==""} { continue }	    
    }
    regsub {.tfas$} $FiSeq "" FiNom
    regsub {.tfas$} $FiSeq "" FiNot
    append FiNom ".noms"
    append FiNot ".nots"

    set LesLignes {}
    foreach FiSeqIn $LesKeepers {
	regsub {.tfas$} $FiSeqIn "" FiNomIn
	regsub {.tfas$} $FiSeqIn "" FiNotIn
	append FiNomIn ".noms"
	append FiNotIn ".nots"
	foreach Seq [LesLignesDuFichier $FiSeqIn] \
		Nom [LesLignesDuFichier $FiNomIn] \
		Not [LesLignesDuFichier $FiNotIn] {
	    lappend LesLignes "$Nom $Not $Seq"
	}
    }
    while 1 {
	set LesBonnes [MorceauxChoisis $LesLignes]
	if {$LesBonnes!=""} { break }
	if {[OuiOuNon "Do we cancel ?"]} { return "" }
    }
    set LesSeq {}
    set LesNom {}
    set LesNot {}
    foreach Ligne $LesBonnes {
	set LesMots [split $Ligne " "]
	set Nom [lindex $LesMots 0]
	set Seq [lindex $LesMots end]
	set Not $Ligne
	regsub "^$Nom " $Not "" Not
	regsub " $Seq$" $Not "" Not
	lappend LesSeq $Seq
	lappend LesNom $Nom
	lappend LesNot $Not
    }
    SauveLesLignes $LesNom dans $FiNom
    SauveLesLignes $LesNot dans $FiNot
    return [SauveLesLignes $LesSeq dans $FiSeq]
}

proc TestSignalsInside {LesPGS {LesSignaux ""}} {
    if {$LesSignaux==""} { set LesSignaux [list "NdeI" "BamHI"] }
    set LesHits {}
    foreach PGS $LesPGS {
	set FiNuc [GscopeFile $PGS "nuctfa"]
	foreach Signal $LesSignaux {
	    set Pattern [Signal $Signal]
	    set PosNPosA [PositionDuPatternDansFichierTFA $Pattern $FiNuc]
	    if {$PosNPosA!="-1 -1"} { lappend LesHits "$PGS [Alias $PGS] $Signal $PosNPosA" }
	}
    }
    return $LesHits
}

proc WithBrocOli {} {
    return [OuiOuNonMemo "Do we use BrocOli (Brocken Oligos) ?\nSo you have to do 2 PCRs." ]
}

proc InventaireDesBrocOli {{Action ""}} {
    if {$Action==""} { set Action "Show" }
    return [AfficheFichier [BrocOli "FileName"]]
}

proc InventaireDesGluOli {{Action ""}} {
    if {$Action==""} { set Action "Show" }
    return [AfficheFichier "[RepertoireDuGenome]/fiches/GluOli.txt"]
}

proc TestBrocOli {} {
    set FicOligos "[RepertoireDuGenome]/atelier/rr/oligos_rr.tfa"
    set FicOligos "[RepertoireDuGenome]/atelier/AnneCath2/oligos_HsCyclinT1-2-533-674-726.tfa"
#    set FicOligos "[RepertoireDuGenome]/atelier/Levy/Ordre2/oligos_AttB1_NdeI-ToDo20080710hsVBP1-BamHI_TEV2_STREP_STOP_AttB2.tfa"
    foreach Access [LaSequenceDuTFAs $FicOligos "LaListeDesAccess"] {
	set TFA [LaSequenceDuTFAs $FicOligos $Access]
	set B [BrocOli $TFA]
	Espionne $B
    }
}

proc BrocOli TFA {
    global BrocOli
    JeMeSignale
    if { ! [info exists BrocOli("EstCharge")]} {
	set BrocOli("EstCharge") 1
	set BrocOli(FileName) "[RepertoireDuGenome]/fiches/BrocOli.txt"
	set BrocOli(ListOfNames) {}
	set BrocOli(AllText) [ContenuDuFichier $BrocOli(FileName)]
	set BrocOli(AllHtml) "<pre>\n$BrocOli(AllText)\n</pre>"
	set BrocOli(ListAll) [split $BrocOli(AllText) "\n"]
	foreach Ligne [LesLignesDuFichier $BrocOli(FileName)] {
	    if {[regexp { *\#} $Ligne]} { continue }
	    regsub {\#.*} $Ligne "" Ligne
	    if { ! [regexp -nocase {[ATGC]} $Ligne]} { continue }
	    scan $Ligne "%s %s" BrocName KeepName
	    regsub "$BrocName +$KeepName" $Ligne "" Ligne
	    regsub -all {[^ATGC ]} [string trim $Ligne] "" BrocAllSeq

	    set IsReverse [regexp "^reverse_" $BrocName]
	    if {$IsReverse} {
		regsub "reverse_" $BrocName "" BrocName
		set BrocAllSeq [NucToReverseAndComplementNuc $BrocAllSeq]
	    }

	    regsub { .+$}   $BrocAllSeq "" BrocLeftSeq
	    regsub {[^ ]+ } $BrocAllSeq "" BrocRightSeq
	    regsub " " $BrocAllSeq "" BrocAllSeq
	    if {[info exists BrocOli($BrocName,Seq)]} {
		FaireLire "I saw already BrocOli($BrocName,Seq) : $BrocOli($BrocName,Seq)"
	    }
	    set BrocOli($BrocName,IsReverse)   $IsReverse
	    set BrocOli($BrocName,KeepName)    $KeepName
	    set BrocOli($BrocName,KeepName)    $KeepName
	    set BrocOli($BrocName,AllSeq)      $BrocAllSeq
	    set BrocOli($BrocName,LeftSeq)     $BrocLeftSeq
	    set BrocOli($BrocName,RightSeq)    $BrocRightSeq
	    lappend BrocOli($BrocAllSeq,Names) $BrocName
	    lappend BrocOli(ListOfNames)       $BrocName
#	    Espionne "$BrocAllSeq"
	}
    }
    if {$TFA=="AllText"}     { return $BrocOli(AllText) }
    if {$TFA=="AllHtml"}     { return $BrocOli(AllHtml) }
    if {$TFA=="ListAll"}     { return $BrocOli(ListAll) }
    if {$TFA=="FileName"}    { return $BrocOli(FileName) }
    if {$TFA=="ListOfNames"} { return $BrocOli(ListOfNames) }

    set Seq [QueLaSequenceDuTexteTFA $TFA]
    set Access [EnteteDuTexteTFA $TFA "access"]

    set Trouve 0
    set LesTrouve {}
    foreach BrocName $BrocOli(ListOfNames) {
	Espionne "Pour $Access On essaye $BrocName"
	if { ! [regexp "^${BrocName}_" $Access] && ! [regexp "_${BrocName}$" $Access]} { continue }
	Espionne "Pour $Access On a trouve $BrocName"
	set IsReverse    $BrocOli($BrocName,IsReverse)
	set KeepName     $BrocOli($BrocName,KeepName)
	set BrocAllSeq   $BrocOli($BrocName,AllSeq)
	set BrocLeftSeq  $BrocOli($BrocName,LeftSeq)
	set BrocRightSeq $BrocOli($BrocName,RightSeq)
	if { ! [regexp -nocase "^$BrocAllSeq" $Seq]} {
	    FaireLire "$TFA\nindicates that it starts with BroOli $BrocName\n\
		    but its sequence doesn't correspond to $BrocAllSeq"
	    continue
	}
	lappend LesTrouve $BrocName
	set Trouve 1
    }
    if { ! $Trouve } { return "" }
    set BrocName [lindex $LesTrouve 0]
    if {[llength $LesTrouve]>1} {
	FaireLire "I found more then 1 BrocOli for \n$TFA\n\nPlease choose the right one ..." "Force"
	while {[set BrocName [ChoixParmi $LesTrouve]]==""} {
	    if {[OuiOuNon "Do we try again" 0 "Force"]} { return [BrocOli $TFA] }
	    if {[OuiOuNon "Do we do without BrocOli" 1 "Force"]} { return "" }   
	}
    }
    set IsReverse    $BrocOli($BrocName,IsReverse)
    set KeepName     $BrocOli($BrocName,KeepName)
    set BrocAllSeq   $BrocOli($BrocName,AllSeq)
    set BrocLeftSeq  $BrocOli($BrocName,LeftSeq)
    set BrocRightSeq $BrocOli($BrocName,RightSeq)
    
    Espionne "BrocName $BrocName"
    regsub -nocase $BrocLeftSeq $Seq "" RestSeq
    if { ! [regexp -nocase $BrocRightSeq $RestSeq]} {
	FaireLire "Something is wrong with BrocOli\n$TFA\n$BrocAllSeq" "Force"
    }
    if {$IsReverse} {
	regsub "_${BrocName}$" $Access "" RestAccess
	regsub -- {^[^_]+_} $Access "" Signaux
	set Entete "${RestAccess}_${KeepName} BrocOli with $BrocName replaces $Signaux"
    } else {
	regsub "${BrocName}_" $Access "" RestAccess
	regsub -- {_[^_]+$} $Access "" Signaux
	set Entete "${KeepName}_${RestAccess} BrocOli with $BrocName replaces $Signaux"
    }
    set NewTFA [SequenceFormatTFA $RestSeq $Entete "nucbrut"]
    Espionne $NewTFA
    return $NewTFA
}

proc LesSignauxDuFichier {FichierSignaux {aSequenceDuSignal ""} {aSequenceDuSignalPourPPCR ""}} {
    if {$aSequenceDuSignal        !=""} { upvar $aSequenceDuSignal         SequenceDuSignal }
    if {$aSequenceDuSignalPourPPCR!=""} { upvar $aSequenceDuSignalPourPPCR SequenceDuSignalPourPPCR }

    if {[info exists SequenceDuSignal]}        { unset SequenceDuSignal }
    if {[info exists SequenceDuSignalPourPCR]} { unset SequenceDuSignalPourPCR }

    if {$FichierSignaux==""} { return {} } 

    set LesSignaux {}
    foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $FichierSignaux] $FichierSignaux NF] {
	if {[regexp "^ *>" $Ligne]} {
	    regsub -all ">" $Ligne " " Ligne
	    scan $Ligne "%s" Signal
	    regsub "_" $Signal "" Signal
	    if {[info exists SequenceDuSignal($Signal)]} {
		if {[string equal -nocase [set SequenceDuSignal($Signal)] [Thrombin]]} {
		    set Signal "ThrombinOld"
		}
		FaireLire "I found two times the same signal $Signal \n in $FichierSignaux"
	    }
	    lappend LesSignaux $Signal
	    set SequenceDuSignal($Signal) ""
	    set SequenceDuSignalPourPPCR($Signal) ""
	    continue
	}
	regsub -nocase -all {[^a-z]} $Ligne "" Seq
	append SequenceDuSignal($Signal) $Seq
	append SequenceDuSignalPourPPCR($Signal) $Seq
	if {[string equal $Signal "ThrombinOld"] && \
		! [string equal [set SequenceDuSignalPourPPCR($Signal)] [ThrombinOld]]} {
	    FaireLire "Problem with signal Thrombin in $FichierSignaux"
	}
    }
    if {[set i [lsearch -exact $LesSignaux "Thrombin"]] > -1 } {
	if {[string equal [set SequenceDuSignalPourPPCR(Thrombin)] [ThrombinOld]]} {
	    set LesSignaux [lreplace $LesSignaux $i $i "ThrombinOld"]
	    set SequenceDuSignal(ThrombinOld) [ThrombinOld]
	    set SequenceDuSignalPourPPCR(ThrombinOld) [ThrombinOld]
	    unset SequenceDuSignal(Thrombin)
	    unset SequenceDuSignalPourPPCR(Thrombin)
	}
    }
    return $LesSignaux
}

proc ChoisisLesSignauxDansLeFichier {Fichier {AvAp ""}} {
    set LesSignaux [LesSignauxDuFichier $Fichier]
    set LesBons [MorceauxChoisis $LesSignaux "" "Transfer the signals to put $AvAp. \n\
	    Then, PLEASE, reorder them (highligh one and press 'Up' or 'Down')\nThen press 'Accept'"]
    return $LesBons
}

proc ChoisisFichierSignauxEtSignaux {{AvAp ""}} {

    if {$AvAp==""} { set AvAp "AvantApres" }
    set Avant [regexp -nocase "Avant" $AvAp]
    set Apres [regexp -nocase "Apres" $AvAp]

    set LesFichiers [LesFichiersDeType "Signaux" "" $AvAp]
    if {[llength $LesFichiers]==0} { return "" }
    if {[llength $LesFichiers]==1} {
	set FichierDesSignauxAvant [lindex $LesFichiers 0]
	set FichierDesSignauxApres [lindex $LesFichiers 0]
    }
    if {[llength $LesFichiers]==2} {
	set FichierDesSignauxAvant [lindex $LesFichiers 0]
	set FichierDesSignauxApres [lindex $LesFichiers 1]
    }
    if {[llength $LesFichiers]>2 \
	    || ( ! $Avant || ! $Apres ) && [llength $LesFichiers] > 1 } {
	if {[OuiOuNon "You choose to much signal files.\n\
		You can MergeSignalFiles and begin again.\n\
		Do You want to do it now ?"]} {
	    MergeSignalFiles
	}
	return ChoisisFichierSignauxEtSignaux $AvAp
    }
    if {$Avant} { set LesAvants [ChoisisLesSignauxDansLeFichier $FichierDesSignauxAvant "at 5' end"]  }
    if {$Apres} { set LesApres  [ChoisisLesSignauxDansLeFichier $FichierDesSignauxApres "at 3' end"] }
    set Texte ""
    append Texte "I took the signals\n\n"
    if {$Avant} {
	append Texte "at 5' end  from the file $FichierDesSignauxAvant\n"
	append Texte "[join $LesAvants " "]\n\n"
    }
    if {$Apres} {
	append Texte "at 3' end  from the file $FichierDesSignauxApres\n"
	append Texte "[join $LesApres " "]\n"
    }
    
    if { ! [OuiOuNon "$Texte\n OK ? "]} {
	if {[OuiOuNon "Do We try again ?"]} { return [ChoisisFichierSignauxEtSignaux $AvAp] }
	if {[OuiOuNon "Do I cancel GenereOligos ?"]} { return {} }
	if {[OuiOuNon "Do I stop ?"]} { Boum }
    }
    if {$Avant && $Apres} { return [list $LesAvants $LesApres $FichierDesSignauxAvant $FichierDesSignauxApres] }
    if {$Avant          } { return [list $LesAvants           $FichierDesSignauxAvant] }
    if {          $Apres} { return [list            $LesApres                         $FichierDesSignauxApres] }
}

proc CodeMutation {Nom {Quoi ""}} {
    if {$Quoi==""} { set Quoi "CodeOnly" }
    set Mut [ExtraitInfo $Nom "Muted:"]
    if {$Quoi=="All"} {return $Mut}
    if {$Mut==""} { return "" }
    regsub {mutation of PGS[0-9]+ [^ ]+ } $Mut "" CodeMutation
    return $CodeMutation
}

proc ShowLesRec1DuVirtualPPCR N {
    if {[regexp "\n" $N]} {
	foreach Nlu [split $N "\n"] {
	    set Fen [ShowLesRec1DuVirtualPPCR $Nlu] 
	}
	return $Fen
    }
    scan $N "%s" N
    set LeTexte {}
    set LesRec1 {}
    foreach R [VirtualPPCREnStock $N LesRec1] {
	Espionne $R
	lappend LesRec1 $R
    }
    Espionne $LesRec1
    return [AfficheLesRec1 $LesRec1]
}

proc CreeLesRec2PourTousLesVEDidierCompatiblesGscope {} {
    set Keep 1
    set LesFichiersCrees {}
    foreach Ligne [LesVEDidierCompatiblesGscope "GetList"] {
	scan $Ligne "%s %s %s" VE R1 Vecteur
	set FicRec1 [Rec1 $R1 "Fichier"]
	Espionne $FicRec1
	if {[FileAbsent $FicRec1]} { continue }
	set VecFile [FindVector $Vecteur]
	set VecName [FindVector NameOf_$Vecteur]
	set FicRec2 "[RepertoireDuGenome]/rec2/${R1}_$VecName"
	if {$Keep && [FileExists $FicRec2]} { continue } 
	set FichierCree [Recombinaison $FicRec1 $VecFile $FicRec2 "" "Seconde"]
	lappend LesFichiersCrees $FichierCree
	Espionne "Rec2 $R1 dans $VecName --> $FichierCree"
    }
    FaireLire "refaire Rec2 en effacant d'abord fiches/rec2"
    return $LesFichiersCrees
}

proc CreeLesRec1PourTousLesVirtualPPCR {} {
    set Keep 1
    set LesFSL {}
    foreach N [VirtualPPCREnStock LaListeDesNs] {
	set FicPPCR [VirtualPPCREnStock $N File]
	if { ! [file exists $FicPPCR]} { continue }
	set FicVect "[RepertoireDuGenome]/vecteurs/pDONR/pDONR207"
	set QueueVect [file tail $FicVect]
	regsub ".tfa" $QueueVect "" QueueVect
	set FicRec1 "[RepertoireDuGenome]/rec1/${N}_$QueueVect"
	if {$Keep && [file exists $FicRec1]} { continue } 
	set Resume [VirtualPPCREnStock $N Resume]
	if { ! [regexp -nocase AttB1 $Resume] || ! [regexp -nocase AttB2 $Resume]} { continue }
	set FSL [Recombinaison $FicPPCR $FicVect $FicRec1 "" "Premiere"]
	lappend LesFSL $FSL
	Espionne "Rec1 $N dans $QueueVect --> $FSL"
    }
    return $LesFSL
}

proc ShowLesVirtualPPCRsDuPGS PGS {
    set LesVirtualPPCRsDuPGS [LesVirtualPPCRsDuPGS $PGS]
    if {$LesVirtualPPCRsDuPGS=={}} {
	FaireLire "No VirtualPPCR were found for $PGS [Alias $PGS]"
	return ""
    }
    set LeTexte {}
    foreach N $LesVirtualPPCRsDuPGS {
	lappend LeTexte [VirtualPPCREnStock $N "Resume"]
    }
    set Titre "VirtualPPCRs_for_[Alias $PGS]_/$PGS" 
    return [AfficheVariable [join $LeTexte "\n"] "AvecVirtualPPCR" $Titre]
}

proc LesVirtualPPCRsDuPGS PGS {
    global LesVirtualPPCRsDuPGS
    if {[info exists LesVirtualPPCRsDuPGS($PGS)]} {
	return [set LesVirtualPPCRsDuPGS($PGS)]
    }
    if {[info exists LesVirtualPPCRsDuPGS("EstCharge")]} { return {} }
    set LesVirtualPPCRsDuPGS("EstCharge") 1
    foreach Loc [LocalisationDesVirtualPPCRs "GetAllLocs"] {
	scan $Loc "%s %s %d %s %d %d %s %d %s" NLu PGSLu DPLu Tiret1 FPLu DNLu Tiret2 FNLu FullNameMemo 
	lappend LesVirtualPPCRsDuPGS($PGSLu) $NLu 
    }
    return [LesVirtualPPCRsDuPGS $PGS]
}

proc ShowLesOligosDuPGS {} {
    set LaPage {}
    foreach PGS [ListeDesPABs] {
	set LesOlis [LesOligosDuPGS $PGS]
	lappend LaPage "$PGS [join $LesOlis " "]"
    }
    set Page [join $LaPage "\n"]
    return [AfficheVariable $Page "AvecOli" "OligosOfAllPGSs"]
}

proc LesOligosDuPGS PGS {
    global LesOligosDuPGS

    if {[info exists LesOligosDuPGS($PGS)]} { return [set LesOligosDuPGS($PGS)] }
    if {[info exists LesOligosDuPGS("EstCharge")]} { return {} }    

    foreach P [Oli "LaListeMerci"] {
	set TypeOli  [Oli $P Type]
	if {$TypeOli!="SynOli"} { continue }
	set PSujets  [Oli $P Subjects]
	set PSignals [Oli $P Signals]
	regsub -all "_" $PSignals " " PSigs
	set PSens    [Oli $P Sens]
	if {$PSens=="5'"} {
	    set POliSignals " === $PSigs === "
	} else {
	    set POliSignals " ===  === $PSigs"
	}
	foreach Ma [MatOl $P Matrice] \
		AA [MatOl $P AA] \
		NA [MatOl $P NA] \
		Or [MatOl $P Orient] \
		Su [MatOl $P Subjects] {
	    set PGSlu [file tail $Ma]
	    lappend LesOligosDuPGS($PGSlu) $P
	}
    }
    set LesOligosDuPGS("EstCharge") 1
    return [LesOligosDuPGS $PGS]
}

proc TestLocalisationDesVirtualPPCRs {} {
    set Loc [LocalisationDesVirtualPPCRs GetLocOf N1733]
    scan $Loc "%s %s %d %s %d %d %s %d %s" NLu PGSLu DPLu Tiret1 FPLu DNLu Tiret2 FNLu FullNameMemo 
    Espionne "$NLu $DPLu $FPLu $DNLu $FNLu"
    set Loc [LocalisationDesVirtualPPCRs GetLocOf N1732]
    scan $Loc "%s %s %d %s %d %d %s %d %s" NLu PGSLu DPLu Tiret1 FPLu DNLu Tiret2 FNLu FullNameMemo 
    Espionne "$NLu $DPLu $FPLu $DNLu $FNLu"
    exit
}

proc LocalisationDesVirtualPPCRs {{Action ""} {NVoulu ""}} {
    global LocalisationDesVirtualPPCRs

    if {$Action==""} { set Action "Show" }

    if {$Action=="GetLocOf" && [info exists LocalisationDesVirtualPPCRs($NVoulu)]} {
	return [set LocalisationDesVirtualPPCRs($NVoulu)]
    }
    if {$Action=="GetLocOf" && [info exists LocalisationDesVirtualPPCRs("EstCharge")]} {
	return ""
    }

    set LesLocs {}
    set LesBads {}

    set LocalisationDesVirtualPPCRs("EstCharge") 1

    set FichierLocalisationDesVirtualPPCRs "[RepertoireDuGenome]/fiches/LocalisationDesVirtualPPCRs"
    if {[file exists $FichierLocalisationDesVirtualPPCRs]} {
	array set LocalisationDesVirtualPPCRs [LesLignesDuFichier $FichierLocalisationDesVirtualPPCRs]
    }

    foreach N [VirtualPPCREnStock "LaListeDesNs"] {
	set PGS      [VirtualPPCREnStock $N "PGS"]
	set SeqSujet [VirtualPPCREnStock $N "SeqSubject"]
	set FullName [VirtualPPCREnStock $N "FullName"]

	if { ! [info exists LocalisationDesVirtualPPCRs($N)]} {
	    set FicTFA "[RepertoireDuGenome]/nuctfa/$PGS"
	    if {[file exists $FicTFA]} { 
		set SeqNuc [QueLaSequenceDuFichierTFA $FicTFA]
		if {[regexp -nocase -indices $SeqSujet $SeqNuc Indices]} {
		    scan $Indices "%d %d" d f
		    set DN [expr $d+1]
		    set FN [expr $f+1]
		    set DP [expr $d/3 + 1]
		    set FP [expr $f/3 + 1]
		} else {
		    set DN -1
		    set FN -1
		    set DP -1
		    set FP -1
		}
	    } else {
		set DN -2
		set FN -2
		set DP -2
		set FP -2
	    }
	    set Ligne [format "%s %s %4d - %4d   %4d - %4d %s" $N $PGS $DP $FP $DN $FN $FullName]
	    set LocalisationDesVirtualPPCRs($N) $Ligne
	} else {
	    set Ligne [set LocalisationDesVirtualPPCRs($N)]
	    scan $Ligne "%s %s %d %s %d %d %s %d %s" NMemo PGSMemo DP Tiret1 FP DN Tiret2 FN FullNameMemo 
	    if {$N!=$NMemo || $PGS!=$PGSMemo} {
		FaireLire "Something is wrong with \n$Ligne\nI expected $N $PGS $FullName"
	    }
	}
	scan $FullName "%s %s" PgsLu SujetLu
	set PpcrName [StringSuivant "ppcr: " dans $FullName]
	scan $PpcrName "%s" SujetPpcr
	if {$SujetLu!=$SujetPpcr} {
	    FaireLire "Different subjects in $Ligne"
	}
	if {[regexp {\-[0-9]+\-[0-9]+$} $SujetLu Match]} {
	    regsub -all {\-} $Match " " Bornes
	    scan $Bornes "%d %d" DLu FLu
	    if {$DP==$DLu && $FP==$FLu} {
	    } else {
		lappend LesBads $Ligne
	    }
	}	    
	lappend LesLocs $Ligne
    }

    if { ! [file exists $FichierLocalisationDesVirtualPPCRs]} {
	SauveLesLignes [array get LocalisationDesVirtualPPCRs] dans $FichierLocalisationDesVirtualPPCRs
    }

    if {$Action=="ShowBad"} {
	return [AfficheVariable [join $LesBads "\n"] "AvecVirtualPPCR" "BadLocalisationDesVirtualPPCRsSurLesPGS"]
    } 
    if {$Action=="Show"} {
	return [AfficheVariable [join $LesLocs "\n"] "AvecVirtualPPCR" "LocalisationDesVirtualPPCRsSurLesPGS"]
    }
    if {$Action=="GetAllLocs"} { return $LesLocs }
    if {$Action=="GetLocOf"} { return [LocalisationDesVirtualPPCRs "GetLocOf" $NVoulu] }
    return $LesLocs
}

proc AfficheRec2 {Selection {Quoi ""}} {
    if {$Quoi==""} { set Quoi "Description" }
    if {[regexp "\n" $Selection]} {
	foreach Ligne [split $Selection "\n"] {
	    AfficheRec2 $Ligne $Quoi
	}
	return
    }
    scan $Selection "%s" R
    if {$Quoi=="Fichier"} { return [AfficheFichier [Rec2 $R $Quoi]] }
    scan $Selection "%s" R
    if {$Quoi=="Fichier"} { return [AfficheFichier [Rec2 $R $Quoi] "AvecFormate"] }
    if {$Quoi=="Rec1"}    {
	set R1 [Rec2 $R "R1"]
	return [AfficheLesRec1 $R1]
    }
    if {$Quoi=="Vecteur"}    {
	set V [Rec2 $R "Vecteur"]
	set Fichier "[RepertoireDuGenome]/vecteurs/pDEST/$V.tfa"
	Espionne $Fichier
	return [AfficheFichier $Fichier "AvecFormate"]
    }
    return [AfficheVariable [Rec2 $R $Quoi]]
}

proc AfficheLesRec2 {{UnRec ""}} {

    if {$UnRec==""} { set Liste [Rec2 LaListeDes Rec2] } else { set Liste [list $UnRec] }

    set LaPage {}
    foreach R $Liste {
	lappend LaPage "[format %-27s $R] Rec2 in [Rec2 $R Vecteur] of [Rec2 $R R1] Rec1 [Rec2 $R Rec1Description]"
    }
    set Page [join $LaPage "\n"]
    set Fen [AfficheVariable $Page "AvecRec2" ListOfRec2]
    if {$Fen==""} { return "" }
    set Clavier "$Fen.buttons"
    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "magenta"
    TouchePour $Clavier "It's File" "AfficheRec2 \[selection get\] Fichier"
    TouchePour <2>      "/Rec1"     "AfficheRec2 \[selection get\] Rec1"
    TouchePour <3>      "/Vector"   "AfficheRec2 \[selection get\] Vecteur"
    return $Fen
}

proc Rec2 {{Qui ""} {Quoi ""}} {
    global Rec2

    Wup "Attention on peut appeler Rec1 R2 pour les infos specif Rec1"

    if {$Qui=="ReLoad"} {
	if {[info exists Rec2]} { unset Rec2 }
	return Rec2
    }

    if {$Qui==""} {
	set Qui "LaListeDes"
	set Quoi "Rec2"
    }
    if {[regexp {^Fus_(.+)$} $Qui Match BonQui]} { set Qui $BonQui }

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

    if {$Quoi=="Sequence"} {
	set Fichier [Rec2 $Qui "Fichier"]
	if {$Fichier==""} { return "" }
	return [QueLaSequenceDuFichierTFA $Fichier]
    }

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

    set FichierRec2 "[RepertoireDuGenome]/fiches/rec2"

    set Rec2("EstCharge") ""
    if {[file exists $FichierRec2]} {
	array set Rec2 [LesLignesDuFichier $FichierRec2]
	return [Rec2 $Qui $Quoi]
    }

    foreach Fichier [glob "[RepertoireDuGenome]/rec2/*"] {
	set Queue [file tail $Fichier]
	set Entete [EnteteDuFichierTFA $Fichier]
	if {$Entete==""} { continue }
	set R2 [EnteteDuFichierTFA $Fichier "access"]
	set Vecteur [StringApres "Rec2 in " dans $Entete]
	set R1 [StringApres "Rec2 in $Vecteur of " dans $Entete]
	set Rec1Description [StringSuivant " Rec1 " dans $Entete]

	set Nom [StringApres " Ppcr for " dans $Entete]
	lappend Rec2($Nom,LesRec2) $R2

	regsub ">" $Entete "" Description
	set Rec2($R2,Description) $Description
	set Rec2($R2,Fichier)     $Fichier
	set Rec2($R2,Vecteur)     $Vecteur
	set Rec2($R2,R1)          $R1
	set Rec2($R2,R2)          $R2
	set Rec2($R2,Rec1Description) $Rec1Description
	
	lappend Rec2($R1,LesFichiers)         $Fichier 
	lappend Rec2($R1,LesRec2)             $R2
	lappend Rec2($R1,LesVecteurs)         $Vecteur
	lappend Rec2(LaListeDes,Fichiers)     $Fichier
	lappend Rec2(LaListeDes,Descriptions) $Description
	lappend Rec2(LaListeDes,Rec2)         $R2
    }
    set Rec2(LaListeDes,Fichiers) [lsort [set Rec2(LaListeDes,Fichiers)]]
    set Rec2(LaListeDes,Rec2)     [lsort [set Rec2(LaListeDes,Rec2)]]
    SauveLesLignes [array get Rec2] dans $FichierRec2
    return [Rec2 $Qui $Quoi]
}

proc AfficheRec1 {Selection {Quoi ""}} {
    JeMeSignale
    if {$Quoi==""} { set Quoi "Description" }
    if {[regexp "\n" $Selection]} {
	foreach Ligne [split $Selection "\n"] {
	    AfficheRec1 $Ligne $Quoi
	}
	return
    }
    scan $Selection "%s" R
    if {$Quoi=="Description"} { return [AfficheLesRec1 $R] }
    if {$Quoi=="Fichier"} { return [AfficheFichier [Rec1 $R $Quoi] "AvecFormate"] }
    if {$Quoi=="Ppcr"}    {
	set N [Rec1 $R "N"]
	return [ShowVirtualPPCR $N]
    }
    if {$Quoi=="Vecteur"}    {
	set V [Rec1 $R "Vecteur"]
	set Fichier "[RepertoireDuGenome]/vecteurs/pDONR/$V"
	Espionne $Fichier
	return [AfficheFichier $Fichier "AvecFormate"]
    }
    return [AfficheVariable [Rec2 $R $Quoi]]
}

proc AfficheLesRec1 {{UnRec ""}} {

    if {$UnRec==""} { set Liste [Rec1 LaListeDes Rec1] } else { set Liste [list $UnRec] }

    set LaPage {}
    foreach R $Liste {
	lappend LaPage [Rec1 $R "Description"]
    }
    set Page [join $LaPage "\n"]
    set Fen [AfficheVariable $Page "AvecRec1" ListOfRec1]
    if {$Fen==""} { return "" }
    set Clavier "$Fen.buttons"
    TouchePour $Clavier NouvelleGamme
    TouchePour $Clavier NouvelleCouleur "magenta"
    TouchePour $Clavier "It's File" "AfficheRec1 \[selection get\] Fichier"
    TouchePour <2>      "/Ppcr"     "AfficheRec1 \[selection get\] Ppcr"
    TouchePour <3>      "/Vect"     "AfficheRec1 \[selection get\] Vecteur"
    return $Fen
}

proc Rec1 {{Qui ""} {Quoi ""}} {
    global Rec1

    if {$Qui=="ReLoad"} {
	if {[info exists Rec1]} { unset Rec1 }
	return Rec1
    }

    if {[regexp {^Fus_(.+)$} $Qui Match BonQui]} { set Qui $BonQui }
    if {[regexp {^(N[0-9]+_[^_]+)_[^_]+$} $Qui Match BonQui]} {	set Qui $BonQui }

    Wup "Rec1 lit le fichier fiches/rec1 qui DOIT ETRE MIS A JOUR (en l'effacant il se recree) !!!!!!!!!!!!!!"
    
    if {$Qui==""} {
	set Qui "LaListeDes"
	set Quoi "Rec1"
    }
    set FichierRec1 "[RepertoireDuGenome]/fiches/rec1"
    if {$Qui=="CreateRec1File"} {
	if {[FileExists $FichierRec1]} {
	    Garde $FichierRec1
	    file delete $FichierRec1
	}
	return [Rec1]
    }
    if {$Quoi==""} { set Quoi "Description" }
    
    if {[info exists Rec1($Qui,$Quoi)]} { return [set Rec1($Qui,$Quoi)] }
    if {[info exists Rec1("EstCharge")]} { return [set Rec1("EstCharge")] }

    set Rec1(LesQuois) [list Description Fichier N Ppcr Vecteur ]


    set Rec1("EstCharge") ""
    if {[file exists $FichierRec1]} {
	array set Rec1 [LesLignesDuFichier $FichierRec1]
	return [Rec1 $Qui $Quoi]
    }

    foreach Fichier [glob "[RepertoireDuGenome]/rec1/N*"] {
	set Queue [file tail $Fichier]
	set Entete [EnteteDuFichierTFA $Fichier]
	if {$Entete==""} { continue }
	set R1 [EnteteDuFichierTFA $Fichier "access"]
	set Vecteur [StringApres "Rec1 in " dans $Entete]
	set N [StringApres "Rec1 in $Vecteur of " dans $Entete]
	set ToutPpcr [StringSuivant " Ppcr for " dans $Entete]

	set Nom [StringApres " Ppcr for " dans $Entete]
	lappend Rec1($Nom,LesRec1) $R1

	regsub ">" $Entete "" Description
	set Rec1($R1,Description) $Description
	set Rec1($R1,Fichier) $Fichier
	set Rec1($R1,Vecteur) $Vecteur
	set Rec1($R1,N)       $N
	set Rec1($R1,Ppcr)    "$N Ppcr for $ToutPpcr"
	
	lappend Rec1($N,LesFichiers)          $Fichier 
	lappend Rec1($N,LesRec1)              $R1
	lappend Rec1($N,LesVecteurs)          $Vecteur
	lappend Rec1(LaListeDes,Fichiers)     $Fichier
	lappend Rec1(LaListeDes,Rec1)         $R1
	lappend Rec1(LaListeDes,Descriptions) $Description
    }
    SauveLesLignes [array get Rec1] dans $FichierRec1
    return [Rec1 $Qui $Quoi]
}

proc CreeLesRec1DeDidier {} {
    foreach E [PEntr "ListeDesEs"] {
	set PE [PEntr $E "All"]
	ScanLaListe [split $PE ","] PGS Alias Fragment Vecteur Oli5P Oli3P PCR Utilisateur
	set LesBons {}
	set LesLocs {}
	foreach N [LesVirtualPPCRsDuPGS $PGS] {
	    set Loc [LocalisationDesVirtualPPCRs "GetLocOf" $N]
	    lappend LesLocs $Loc
	    set  SujetPPCR [StringApres "ppcr:" dans $Loc]
	    if {$SujetPPCR==""} { continue }
	    if {$SujetPPCR==$Fragment} {
		lappend LesBons $Loc
	    } else {
		while 1 {
		    if {[regexp {\-1\-} $Fragment] && [regexp {\-2\-} $SujetPPCR]} {
			regsub {\-1\-} $Fragment "-2-" VraiFragment
			if {$SujetPPCR==$VraiFragment} {
			    lappend LesBons $Loc
			}
			break
		    }
		    scan $Loc "%s %s %d %s %d %d %s %d %s" \
			    NLu PGSLu DPLu Tiret1 FPLu DNLu Tiret2 FNLu FullNameMemo 
		    set VraiFragment "$Fragment-$DPLu-$FPLu"
		    if {$SujetPPCR==$VraiFragment} {
			lappend LesBons $Loc
			break
		    }
		    if {[regexp "XPDhs" $Fragment]} {
			regsub "XPDhs" $Fragment "p80hs" Fragment
			continue
		    }
		    break
		}
	    }
	}
	if {[llength $LesBons]!=1} {
	    Espionne "J'ai trouve [llength $LesBons] locs pour $E"
	    Espionne $PE
	    EspionneL $LesLocs
	    Espionne ""
	}
    }
}

proc InventaireDesPEntr {{Action ""}} {
    foreach E [PEntr "ListeDesEs"] {
	set PE [PEntr $E]
	set iChamp 0
	foreach Champ [split $PE ","] {
	    incr iChamp 
	    if { ! [info exists LargeurDuChamp($iChamp)]} { set LargeurDuChamp($iChamp) 1 }
	    set LargeurDuChamp($iChamp) [Maxi $LargeurDuChamp($iChamp) [string length $Champ]]
	}
    }
    set LeShow {}
    foreach E [PEntr "ListeDesEs"] {
	set PE [PEntr $E]
	set LaLigne "$E  "
	set iChamp 0
	foreach Champ [split $PE ","] {
	    incr iChamp 
	    lappend LaLigne [format "%-[set LargeurDuChamp($iChamp)]s" $Champ]
	}
	lappend LeShow [join $LaLigne " "]
    }
    set Show [join $LeShow "\n"]
    return [AfficheVariable $Show "" "Inventory_of_PEntr"]
}

proc PEntr {{E ""} {Quoi ""}} {

    if {$E==""} { set E "ListeDesEs" }
    if {$Quoi==""} { set Quoi "All" }
    
    if {$E=="ListeDesEs"}   { return [PEntrDidier "ListeDesEs"] }
    if {$E=="ListeDesPGSs"} { return [PEntrDidier "ListeDesPGSs"] }

    set PE [PEntrDidier $E]

    if {$Quoi=="All"} { return $PE }

    ScanLaListe [split $PE ","] PGS Alias Fragment Vecteur Oli5P Oli3P PCR Utilisateur

    if {$Quoi=="PGS"}         { return $PGS }
    if {$Quoi=="Alias"}       { return $Alias }
    if {$Quoi=="Fragment"}    { return $Fragment }
    if {$Quoi=="Vecteur"}     { return $Vecteur }
    if {$Quoi=="Oli5P"}       { return $Oli5P }
    if {$Quoi=="Oli3P"}       { return $Oli3P }
    if {$Quoi=="PCR"}         { return $PCR }
    if {$Quoi=="Utilisateur"} { return $Utililsateur }
    FaireLire "Wrong call to PEntr"
    return $PE
}

proc PEntrDidier {E {Val ""} {Val2 ""}} {
    global PEntrDidier

    Wup "E can be E1234 PGS123 Save or Load"
    Wup "Save must be done"

    set Append 0
    if {$Val=="append"} { set Append 1 ; set Val $Val2 } 

    set FichierPEntrDidier "[RepertoireDuGenome]/fiches/PEntrDidier"

    if {$E=="Save"} {
	if {[info exists PEntrDidier("EstCharge")]} { unset PEntrDidier("EstCharge") }
	if {[info exists PEntrDidier(ListeDesEs)]}  { unset PEntrDidier(ListeDesEs) }
	SauveLesLignes [array get PEntrDidier] dans $FichierPEntrDidier
	catch {unset PEntrDidier}
	PEntrDidier "Load"
	return $FichierPEntrDidier
    }

    if {$Val!=""} {
	if {$Append} {
	    lappend PEntrDidier($E) $Val
	} else {
	    set PEntrDidier($E) $Val
	}
	if {[EstUnPAB $E]} {
	    lappend PEntrDidier(ListeDesPGSs) $E
	    set PEntrDidier(ListeDesPGSs) [lsort -unique [set PEntrDidier(ListeDesPGSs)]]
	} else {
	    lappend PEntrDidier(ListeDesEs) $E
	    set PEntrDidier(ListeDesEs) [lsort -unique [set PEntrDidier(ListeDesEs)]]
	}
	return [set PEntrDidier($E)]
    }

    if {$E!="Load"} {
	if {[info exists PEntrDidier($E)]}          { return [set PEntrDidier($E)] }
	if {[info exists PEntrDidier("EstCharge")]} { return [set PEntrDidier("EstCharge")] }
    }
    if { ! [file exists $FichierPEntrDidier]} {
	set PEntrDidier("EstCharge") "NoValueAvailable"
	return "NoValueAvailable"
    }

    array set PEntrDidier [LesLignesDuFichier $FichierPEntrDidier]
    foreach {EouPGS Valeur} [array get PEntrDidier] {
	if {[EstUnPAB $EouPGS]} {
	    lappend PEntrDidier(ListeDesPGSs) $EouPGS
	    continue
	}
	if {[regexp {^E[0-9]+$} $EouPGS]} {
	    lappend PEntrDidier(ListeDesEs) $EouPGS
	}
    }
    set PEntrDidier(ListeDesPGSs) [lsort [set PEntrDidier(ListeDesPGSs)]]
    set PEntrDidier(ListeDesEs) [lsort [set PEntrDidier(ListeDesEs)]]
    set PEntrDidier("EstCharge") ""

    if {$E=="Load"} { return $FichierPEntrDidier }    
    return [PEntrDidier $E]
}

proc ChargeCloDoE {} {

    if { ! [OuiOuNon "OK to reload PEntrDidier"]} {return ""}

    set LesMauvais {}
    set LesLignesCodeMute {}

    foreach E [CloDo "ListAllPlease" pENTR] {
	set Fragment [CloDo "fragment" $E]
	set Vecteur [CloDo "vecteur" $E]
	set PCR [CloDo "PCR" $E]
	set Oli5P [CloDo "primer_sens" $E]
	set Oli3P [CloDo "primer_antisens" $E]
	set Utilisateur [CloDo "Utilisateur" $E]

	set Alias $Fragment
	regsub {\-[0-9]+\-[0-9]+$} $Alias "" Alias
	if {[regexp {[a-z]+TAF[0-9]+} $Fragment Match]} {
	    set Alias $Match
	}
	set PGS [NomDuAlias $Alias]
	if {$PGS==""} {
	    if {[regexp "^VDR" $Alias]} { continue }
	    if {[regexp {\-[A-Z][0-9]+[A-Z]$} $Alias]} {
		set Al "XXXX"
		set LesCodeMute {}
		foreach CodeMute [split $Alias "-"] {
		    if { ! [regexp {^[A-Z][0-9]+[A-Z]$} $CodeMute]} {
			set Al $CodeMute
			continue
		    }
		    lappend LesCodeMute $CodeMute
		}
		set PGSOrig [NomDuAlias $Al]
		set LigneCodeMute "$PGSOrig $PGSOrig $LesCodeMute"
		set BonneLigneCodeMute [Entre $LigneCodeMute]
		if {$BonneLigneCodeMute!=""} { lappend LesLignesCodeMute $BonneLigneCodeMute }
	    }
	    lappend LesMauvais "$E $Fragment $Alias $Vecteur $Oli5P $Oli3P $PCR $Utilisateur"
	    continue
	}
	set Valeur "$PGS,$Alias,$Fragment,$Vecteur,$Oli5P,$Oli3P,$PCR,$Utilisateur"
	Espionne "$E $Valeur"
	PEntrDidier $E $Valeur
	PEntrDidier $PGS append "$E"
    }
    EspionneL $LesMauvais
    EspionneL $LesLignesCodeMute
    return [PEntrDidier "Save"]
}

proc TestLambdaIntegrase2 {} {
    set SeqRec1  [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/rec1/N1733_pDONR207"]
    set SeqPDest [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/vecteurs/pDEST/pDEST17.tfa"]
    set LesBornes [LesBornesParLambdaIntegrase $SeqRec1 $SeqPDest [SEQAttL1] [SEQAttL2]] 
    Espionne $LesBornes
    exit
}

proc TestLambdaIntegrase {} {
    set SeqPPCR  [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/ppcr_virtuels/N1733"]
    set SeqSiteP [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/vecteurs/pDONR/pDONR207.tfa"]
    set LesBornes [LesBornesParLambdaIntegrase $SeqPPCR $SeqSiteP [SEQAttB1] [SEQAttB2]] 
    Espionne $LesBornes
    exit
}

proc LesBornesParLambdaIntegrase {SeqPPCR SeqSiteP SeqAttB1 SeqAttB2} {
    set SeqPPCR  [string toupper $SeqPPCR]
    set SeqSiteP [string toupper $SeqSiteP]
    set SeqAttB1 [string toupper $SeqAttB1]
    set SeqAttB2 [string toupper $SeqAttB2]

    set LesPositions {}
    foreach Seq [list $SeqPPCR $SeqSiteP] {
	foreach S [list $SeqAttB1 $SeqAttB2] {
	    set LongueurAttB [string length $S]
	    set Offset 0
	    while {[set Pos [string first $S $Seq]]<0 } {
		incr Offset
		set S [string range $S 1 end-1]
		if {[string length $S]<5} {return ""}
		Espionne $S
	    }
	    set AutrePos [string last $S $Seq]
	    if {$Pos!=$AutrePos} { FaireLire "I found two AttB at $Pos and $AutrePos" }
	    set PosMilieuAttB [expr $Pos - $Offset + $LongueurAttB/2]
	    Espionne "$Pos  $Offset $PosMilieuAttB $S"
	    lappend LesPositions $PosMilieuAttB
	}
    }
    
    return $LesPositions
}

proc CreePrimers Fichier {
    set LesGenes {}
    set LesPrimersN {}
    set LesPrimersC {}
    set DansGenes 0
    set DansPrimers 0
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	if {$Ligne=="Genes"}   { set DansPrimers 0 ; set DansGenes 1 ; continue }
	if {$Ligne=="Primers"} { set DansPrimers 1 ; continue }
	if {$DansPrimers} {
	    scan $Ligne "%s %s %s %s" FichPlasmide SeqPrimer NomDuPrimer NouCter
	    if {$NouCter=="N"} {
		lappend LesPrimersN $SeqPrimer
		lappend LesTitresPrimersN "$NomDuPrimer $NouCter from $FichPlasmide"
	    } else {
		lappend  LesPrimersC $SeqPrimer
		lappend LesTitresPrimersC "$NomDuPrimer $NouCter from $FichPlasmide"
	    }
	    continue
	}
	if {$DansGenes} {
	    scan $Ligne "%s" FichierSeq
	    lappend LesGenes [QueLaSequenceDuFichierTFA $FichierSeq]
	    regsub {\-.*$} $FichierSeq "" TitreSeq
	    lappend LesTitresGenes "$TitreSeq"
	}	
    }

    set LongHybridationP 15
    set LongHybridationN [expr $LongHybridationP*3]
    set LongPromoteurP 17
    set LongPromoteurN [expr $LongPromoteurP*3]

    foreach Gene $LesGenes Titre $LesTitresGenes {
	foreach Primer $LesPrimersN TitrePrimer $LesTitresPrimersN {
	    if {[regexp "UpstreamPrimerA" $TitrePrimer]} {
		set Seq [string range "n$Gene" \
			[expr $LongPromoteurN-$LongHybridationN]  \
			[expr $LongPromoteurN] ]
		set Oligo "$Seq $Primer"
		set Entete "$Titre with $TitrePrimer"
		regsub -all " " $Entete "-" Entete
		Espionne ">$Entete\n$Oligo"
	    }
	    if {[regexp "UpstreamPrimerB" $TitrePrimer]} {
		set Seq [string range "$Gene" \
			[expr $LongPromoteurN] \
			[expr $LongPromoteurN+$LongHybridationN]]
		set Rac [NucToReverseAndComplementNuc $Seq]
		set Oligo "$Rac $Primer"
		set Entete "$Titre with $TitrePrimer"
		regsub -all " " $Entete "-" Entete
		Espionne ">$Entete\n$Oligo"
	    }
	}
	foreach Primer $LesPrimersC TitrePrimer $LesTitresPrimersC {
	    if {[regexp "UpstreamPrimerA" $TitrePrimer]} {
 		set Seq [string range "x$Gene" \
			"end-[expr $LongPromoteurN+$LongHybridationN]" \
			"end-[expr $LongPromoteurN]"]
		set Oligo "$Seq $Primer"
		set Entete "$Titre with $TitrePrimer"
		regsub -all " " $Entete "-" Entete
		Espionne ">$Entete\n$Oligo"
	    }
	    if {[regexp "UpstreamPrimerB" $TitrePrimer]} {
 		set Seq [string range "x$Gene" \
			"end-[expr $LongPromoteurN -1]" \
			"end-[expr $LongPromoteurN-$LongHybridationN -1]"]
		set Rac [NucToReverseAndComplementNuc $Seq]
		set Oligo "$Rac $Primer"
		set Entete "$Titre with $TitrePrimer"
		regsub -all " " $Entete "-" Entete
		Espionne ">$Entete\n$Oligo"
	    }
	}
    }
}

proc GenesSurPlamides Fichier {
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	scan $Ligne "%s %s %s %s" FichPlasmide SeqPrimer NomDuPrimer NouCter
	set Sens "Direct"
	set PosN [PositionDuPatternDansFichierTFA $SeqPrimer $FichPlasmide $Sens "NA" "Circulaire"]
	if {$PosNuc==-1} {
	    set Sens "RaC"
	    set PosN [PositionDuPatternDansFichierTFA $SeqPrimer $FichPlasmide $Sens "NA" "Circulaire"]
	}
	if {$PosNuc==-1} {
	    FaireLire "I didn't find $SeqPrimer in $FichPlasmide"
	    continue
	}
	Espionne "$Ligne $PosNuc $Sens"
	
    }
    exit
}

proc LesLongueursDesProteines {{GetWhat ""}} {
    set LaSortie {}
    foreach Nom [ListeDesPABs] {
	set SeqPro [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"]
	set L [string length $SeqPro]
	lappend LaSortie "$Nom [Alias $Nom] $L"
    }
    if {[string equal -nocase "GetList"]} { return $LaSortie }
    if {[string equal -nocase "GetText"]} { return [join $LaSortie "\n"] }
    return [AfficheListe $LaSortie "" "Proteins Length"]
}

proc CorrigeRec2 {} {
    foreach Fichier [glob "[RepertoireDuGenome]/rec2/N*"] {
	set Queue [file tail $Fichier]
	set TFA [ContenuDuFichier $Fichier]
	set Entete [EnteteDuTexteTFA $TFA]
	scan $Entete "%s" Access
	regsub ">" $Access "" Access
	set pDEST [lindex [split $Access "_"] end]
	regsub "_$pDEST$" $Access "" Rec1
	regsub "Rec2 with " $Entete "Rec2 in $pDEST of $Rec1 Rec1 in " NouvelleEntete
	set LeTFA [split $TFA "\n"]
	set LeNouveauTFA [list $NouvelleEntete]
	LConcat LeNouveauTFA [lrange $LeTFA 1 end]
	Espionne [SauveLesLignes $LeNouveauTFA dans "[RepertoireDuGenome]/rec2nouveau/$Queue" ]
    }
}


proc LesSignaux {} {
    set FichierDesSignaux "[RepertoireDuGenome]/signaux/signaux.tfa"
    set LesSignaux [LesSignauxDuFichier $FichierDesSignaux]
    return $LesSignaux
}

proc LeBonOrdrePourLesSignaux {{NouvelOrdre ""} {ASauver ""}} {
    global LeBonOrdrePourLesSignaux
    global RepertoireDuGenome

    set FichierOrdreDesSignaux "$RepertoireDuGenome/signaux/ordredessignaux"

    if {$NouvelOrdre!=""} { set LeBonOrdrePourLesSignaux $NouvelOrdre }
    if {$ASauver=="ASauver"} { SauveLesLignes $LeBonOrdrePourLesSignaux dans $FichierOrdreDesSignaux }

    if {[info exists LeBonOrdrePourLesSignaux]} { return $LeBonOrdrePourLesSignaux }

    if { ! [file exists $FichierOrdreDesSignaux]} { return {} }
    set LeBonOrdrePourLesSignaux [LesLignesDuFichier $FichierOrdreDesSignaux]
    return $LeBonOrdrePourLesSignaux
}

proc InventaireDesSignauxGroupes TousLesSignauxGroupes {

    if {[regexp "\n" $TousLesSignauxGroupes]} {
	set TousLesSignauxGroupes [split $TousLesSignauxGroupes "\n"]
    }

    foreach Signaux $TousLesSignauxGroupes {
	set LesSignaux [split $Signaux "_"]
	set i 0
	foreach Prems $LesSignaux {
	    lappend LesPrems $Prems
	    foreach Deuss [lrange $LesSignaux [incr i] end] {
		set Ordre($Prems,$Deuss) $Signaux
		if {[info exists Ordre($Deuss,$Prems)]} {
		    if {[OuiOuNon "wrong signal order $Prems $Deuss in $Signaux\
			    \nPrevious was [set Ordre($Deuss,$Prems)]\
			    \nDo I keep the old one ?"]} {
			unset Ordre($Prems,$Deuss)
		    } else {
			unset Ordre($Deuss,$Prems)
		    }  
		}
	    }
	}
    }
    EspionneL [array get Ordre]
    set Encore 1
    while {$Encore} {
	if {[info exists EstDeuxieme]} { unset EstDeuxieme }
	set Encore 0
	foreach {PD Signaux} [array names Ordre] {
	    ScanLaListe [split PD ","] Prems Deuss
	    if {[info exists DejaVu($Prems)]} { continue }
	    set EstDeuxieme($Deuss) $Prems
	}
	foreach {PD Signaux} [array names Ordre] {
	    ScanLaListe [split $PD ","] Prems Deuss
	    if {[info exists EstDeuxieme($Prems)]} { continue }
	    if {[info exists DejaVu($Prems)]} { continue }
	    lappend LeBonOrdre $Prems
	    set DejaVu($Prems) 1
	    set Encore 1 
	}
    }
    foreach P [lsort -unique $LesPrems] {
	if {[info exists DejaVu($P)]} { continue }
	lappend LeBonOrdre $P
    }
    if {[OuiOuNon "Do I append this order to the signals-order-file ?"]} {
	set AncienOrdre [LeBonOrdrePourLesSignaux]

	set NouvelOrdre [concat $AncienOrdre $LeBonOrdre]
	set LeBonOrdre {}
	foreach Signal $NouvelOrdre {
	    if {[info exists Vu($Signal)]} { continue }
	    set Vu($Signal) 1
	    lappend LeBonOrdre $Signal
	}
	LeBonOrdrePourLesSignaux $LeBonOrdre "ASauver"
    }
	
    EspionneL  $LeBonOrdre
    return $LeBonOrdre
} 

proc TestCorrectionPourThrombin {Fi} {
    return [CorrectionPourThrombin [LesLignesDuFichier $Fi] $Fi zz]
}

proc CorrectionPourThrombin {LesLignes Fichier aNouveauNom} {
    upvar $aNouveauNom NouveauNom

    set NouveauNom $Fichier

    if {[regexp "^/home/" $LesLignes]} {
	set LesLignes [LesLignesDuFichier $LesLignes]
    }

    if {[lsearch -regexp $LesLignes "Thrombin"   ]==-1} { return $LesLignes }
    if {[lsearch -regexp $LesLignes "ThrombinOld"] >-1} { return $LesLignes } 
    set Texte [join $LesLignes "\n"]
    regsub -all "\n" $Texte "" TexteSeq
    regsub -all " "  $TexteSeq "" TexteSeq
    if { ! [regexp -nocase "[ThrombinOld]" $TexteSeq]} { return $LesLignes }
    regsub -all "Thrombin" $Texte   "ThrombinOld" NouveauTexte
    regsub -all "thrombin" $Fichier "thrombinold" NouveauNom
    return [split $NouveauTexte "\n"]
}

proc Thrombin {} {
    return "CTGGTGCCACGCGGTTCT"
}

proc ThrombinOld {} {
    return "CTGGTGCCGCGCGGCAGC"
}

proc SEQAttB1Adapter {} {
    return "AAAAAGCAGGCTTC"
}

proc SEQAttB1AddToInvitrogen {} {
    return "TC"
}

proc SEQAttB1Invitrogen {} {
    Wup "This is the short AttB1 signal, frame is wrong so it need add of TC"
    return "GGGGACAAGTTTGTACAAAAAAGCAGGCT"
}

proc SEQAttB1 {} {
    return "GGGGACAAGTTTGTACAAAAAAGCAGGCTTC"
}

proc SEQAttL1 {} {
    return "CCAACTTTGTACAAAAAAGC"
}

proc SEQAttL2 {} {
    return "CAGCTTTCTTGTACAAAGT"
}

proc SEQAttL2RaC {} {
    return [NucToReverseAndComplementNuc [SEQAttL2]]
}

proc SEQAttR1 {} {
    return "ACAAGTTTGTACAAAAAAGCTGAAC"
}

proc SEQAttR2 {} {
    return "GTTCAGCTTTCTTGTACAAAGTGGT"
}

proc SEQAttR2RaC {} {
    return [NucToReverseAndComplementNuc [SEQAttR2]]
}

proc CaCommenceParAttB Seq {
    set Seq [string toupper $Seq]
    if {[string first [SEQAttB1Invitrogen]    $Seq]==0} { return 1 }
    if {[string first [SEQAttB2InvitrogenRaC] $Seq]==0} { return 2 }
    return 0
}

proc RetireAttB Seq {
    set Seq [string toupper $Seq]
    if {[string first [SEQAttB1Invitrogen]    $Seq]==0} { regsub [SEQAttB1Invitrogen]    $Seq "" Bon ; return $Bon}
    if {[string first [SEQAttB2InvitrogenRaC] $Seq]==0} { regsub [SEQAttB2InvitrogenRaC] $Seq "" Bon ; return $Bon}
    return $Seq
}

proc SEQAttB1Begin {} {
    regsub [SEQAttB1Adapter] [SEQAttB1] "" Debut
    return $Debut
}

proc SEQAttB2Adapter {} {
    return "GACCCAGCTTTCT"
}

proc SEQAttB2AddToInvitrogen {} {
    return "G"
}

proc SEQAttB2Invitrogen {} {
    Wup "This is the short AttB2 signal. frame is wrong so it needs add of G "
    return "ACCCAGCTTTCTTGTACAAAGTGGTCCCC"
}

proc SEQAttB2 {} {
    return "GACCCAGCTTTCTTGTACAAAGTGGTCCCC"
}

proc SEQAttB2AddToInvitrogenRaC {} {
    return [NucToReverseAndComplementNuc [SEQAttB2AddToInvitrogen]]
}

proc SEQAttB2InvitrogenRaC {} {
    return [NucToReverseAndComplementNuc [SEQAttB2Invitrogen]]
}

proc SEQAttB2RaC {} {
    return [NucToReverseAndComplementNuc [SEQAttB2]]
}

proc SEQAttB2AdapterRaC {} {
    return [NucToReverseAndComplementNuc [SEQAttB2Adapter]]
}

proc SEQAttB2End {} {
    regsub [SEQAttB2Adapter] [SEQAttB2] "" Fin
    return $Fin
}

proc SEQAttB2EndRaC {} {
    return [NucToReverseAndComplementNuc [SEQAttB2End]]
}