Index by: file name |
procedure name |
procedure call |
annotation
gscope_closig.tcl
(annotations | original source)
#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]]
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.