Index by: file name |
procedure name |
procedure call |
annotation
gscope_atelier.tcl
(annotations | original source)
#rR Debut de gscope_atelier.tcl
#rR il y a ici un peu de tout ... c'est l'atelier quoi ...
proc PP {A1 {A2 a2} {A3 "aaa 333"} {A4 {a b c d}}} {
Wup "je ne fais rien"
}
proc ArgumentListWithDefault {Proc} {
set LesArguments [info args $Proc]
set LesArgDef {}
foreach Arg $LesArguments {
if {[info default $Proc $Arg Defaut]} {
lappend LesArgDef [list $Arg $Defaut]
} else {
lappend LesArgDef $Arg
}
}
return $LesArgDef
}
proc ProcPourBioTcl {Proc Modele {LaDocu {}}} {
if {[info procs $Proc]=={}} { return "" }
if {$Modele==""} { return "" }
set LesArgDef [ArgumentListWithDefault $Proc]
set OldName $Proc
set OldArgs $LesArgDef
set NewName [lindex $Modele 0]
set NewArgs [lindex $Modele 1]
set NS ""
regexp {^([^\:]+)\:\:} $NewName Match NS
regsub {^([^\:]+)\:\:} $NewName "" NewName
Espionne "*****************************"
Espionne $LaDocu
Espionne $OldName
Espionne =$OldArgs=
Espionne $NewName
Espionne =$NewArgs=
if {$NewArgs=={}} { set NewArgs $OldArgs }
set NewProc ""
if {$LaDocu!={}} { EspionneL $LaDocu; append NewProc \n[join $LaDocu "\n"]}
append NewProc "\nproc $NewName "
set LesNewArgs {}
set CallingArgs {}
foreach OldAD $OldArgs NewAD $NewArgs {
set OldArg [lindex $OldAD 0]
set OldDef [lindex $OldAD 1]
set NewArg [lindex $NewAD 0]
set NewDef [lindex $NewAD 1]
if {$NewDef==""} { set NewDef $OldDef }
if {[llength $OldAD]==1} {
lappend LesNewArgs $NewArg
} else {
lappend LesNewArgs [list $NewArg $NewDef]
}
lappend CallingArgs $NewArg
}
append NewProc "\{"
append NewProc $LesNewArgs
append NewProc "\} \{"
append NewProc "\n"
append NewProc " return \[::$Proc"
foreach NewArg $CallingArgs {
append NewProc " \$$NewArg"
}
append NewProc "\]"
append NewProc "\n\}"
Espionne $NewProc
return [list $NewProc $NS]
}
proc AddToBioTclSources {FichierSource {NameSpaceParDefaut ""}} {
if {$NameSpaceParDefaut==""} {
set Queue [file tail $FichierSource]
set NameSpaceParDefaut $Queue
regsub "^(gscope|ordali)_" $NameSpaceParDefaut "" NameSpaceParDefaut
regsub "\.tcl$" $NameSpaceParDefaut "" NameSpaceParDefaut
}
set Date [Date Nice]
set ModeleBioTcl ""
set ProcCourante ""
set LaDocu {}
set LaDocuDuSuivant {}
set LesDestins {}
set DocAPrendre 0
foreach Ligne [LesLignesDuFichier $FichierSource] {
if { ! $DocAPrendre && $Ligne==""} { set DocAPrendre 1 }
if {$DocAPrendre && [regexp {^[\t ]*#} $Ligne]} { lappend LaDocu $Ligne }
if {[regexp {^proc ([^ ]+) } $Ligne Match Proc]} {
Espionne $ProcCourante $ModeleBioTcl $LaDocu
set NewProcNS [ProcPourBioTcl $ProcCourante $ModeleBioTcl $LaDocuDuSuivant]
lassign $NewProcNS NewProc NS
if {$NS==""} {
set NS $NameSpaceParDefaut
}
set Destin "/home/ripp/biotcl/src/$NS.tcl"
if { ! [info exists DejaOuvert($Destin)] } {
lappend LesDestins $Destin
AppendAuFichier $Destin "#BioTcl interface $Date\n\nnamespace eval $NS \{"
set DejaOuvert($Destin) 1
}
if {$NewProc!=""} { AppendAuFichier $Destin $NewProc }
set ModeleBioTcl ""
set ProcCourante $Proc
set LaDocuDuSuivant $LaDocu
set LaDocu {}
continue
}
if {[regexp "\}" $Ligne]} { set LaDocu {} }
if {[regexp {^[ \t]+#biotcl (.+)$} $Ligne Match Modele]} {
set ModeleBioTcl $Modele
continue
}
}
foreach Destin [lsort -unique $LesDestins] {
AppendAuFichier $Destin "\n\}"
}
return $LesDestins
}
proc ShowImage Fichier {
if {[FileAbsent $Fichier]} { return "" }
if {[regexp -nocase ".jpg$" $Fichier]} {
set PID [exec eog $Fichier &]
return $PID
}
set I [image create photo Ima -file $Fichier]
set W [image width $I]
set H [image height $I]
set W2 [expr $W/2]
set H2 [expr $H/2]
set KW [Mini 1024 $W]
set KH [Mini 1024 $H]
set K [UnCanva $KW $KH $W $H]
$K create image $W2 $H2 -image Ima -tags "Image"
return $K
}
proc DecoupeBlast {{Gros ""}} {
file mkdir Blastx
set LesFichiersCrees {}
set OnEstDansEntete 1
set LEnTete {}
Espionne $Gros
foreach Ligne [LesLignesDuFichier $Gros] {
#Espionne $Ligne
if {[regexp "^Query=" $Ligne]} {
if {$OnEstDansEntete} {
set OnEstDansEntete 0
}
if { ! [regexp {^Query= (.+)$} $Ligne Match Moi]} {
FaireLire "Pas de nom dans $Ligne"
return ""
}
set FicBlast "Blastx/$Moi.blastx"
set MesLignes {}
lappend MesLignes [join $LEntete "\n"]
lappend MesLignes $Ligne
continue
}
if {$OnEstDansEntete} {
lappend LEntete $Ligne
continue
}
if {[regexp "^Effective" $Ligne]} {
lappend MesLignes $Ligne
lappend MonBlast [join $MesLignes "\n"]
SauveLesLignes $MesLignes dans $FicBlast
lappend LesFichiersCrees $FicBlast
continue
}
lappend MesLignes $Ligne
}
return $LesFichiersCrees
}
proc DomainesDuFastaCM {} {
set LesTfas {}
set Canal [open "/home/mayer/PABPC1L/structures_RRM.csv" "r"]
set OldAccess ""
while {[gets $Canal Ligne]>=0} {
lassign [split $Ligne ";"] Access Bornes
if {$Access == ""} {set Access $OldAccess}
set OldAccess $Access
if {[regexp " " $Access]} {continue}
if {$Bornes == ""} { continue }
scan $Bornes "%d %s %d" D M F
puts "************************************"
puts $Ligne
puts "$Access $Bornes $D $F"
set Embl [GeneQuid UniProt $Access]
set LesLignesEMBL [split $Embl "\n"]
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX Seq
#set Seq [string repeat "ABCDEF" 1000]
set Zone [string range "x$Seq" $D $F]
set ADF "${Access}_${D}_$F"
set Tfa [SequenceFormatTFA $Zone $ADF "protbrut"]
lappend LesTfas $Tfa
puts $Zone
}
#set Sortie [SauveLesLignes $LesTfas dans "/home/mayer/PABPC1L/structures_RRM.fasta"]
set Sortie [SauveLesLignes $LesTfas dans "/home/ripp/structures_RRM.fasta"]
return $Sortie
}
proc ProgsToBiolo {} {
foreach Ligne [LesLignesDuFichier "/biolo/setbiolo.com"] {
scan $Ligne "%s %s %s %s" a Alias Source F
if { ! [regexp "/biolo/progs/set(.+)\.com" $F Match BioloDir]} { continue }
Espionne "\n\n\n$Ligne $BioloDir ********************"
Espionne [ContenuDuFichier $F]
}
foreach FiCom [lsort [glob "/biolo/progs/set*.com"]] {
}
return ProgsToBiolo
}
proc SetcomToModule {} {
foreach Commande "setenv addpath addpathend addldlibrarypath addmanpath ls lsx echo exit alias" {
set Adopte($Commande) 1
}
foreach Ligne [LesLignesDuFichier "/biolo/setbiolo.com"] {
set LesMots [LesMotsDuTexte $Ligne]
lassign $LesMots alias Alias Source FiCom
if {$Source != "source"} { continue }
set Dir [file dirname $FiCom]
if {[FileAbsent $Dir]} { Espionne "pas de dir pour" $Alias $Dir }
if {[FileAbsent $FiCom]} { Espionne $Alias $FiCom }
set Texte [ContenuDuFichier $FiCom]
set LesBad {}
foreach Ligne [split $Texte "\n"] {
regsub "#.+$" $Ligne "" Ligne
set Ligne [string trim $Ligne " \t"]
if {$Ligne==""} { continue }
scan $Ligne "%s" Commande
if {[info exists Adopte($Commande)]} { continue }
lappend LesBad $Ligne
}
if {$LesBad=={}} { continue }
#Affiche $Texte "AvecRetour"
Espionne "\n\n\n*************************** $Alias\t$FiCom"
Espionne $Texte
}
}
proc TB {} {
return [exec bash --login -c {setordalilm ; echo $ORDALIDIR}]
}
proc CleanBiolo {} {
if {0} {
NousAllonsAuBoulot /biolo
foreach FicSet [lsort [glob "progs/set*.com"]] {
#Espionne $FicSet
set Texte [ContenuDuFichier $FicSet]
if { ! [regexp {(/biolo/[^/'`\" \n]+)(['/`\" \n]|$)} $Texte Match Rep]} { continue }
set Rep [string trim $Rep {'}]
if {[FileAbsent $Rep]} { Espionne "pas de $Rep pour $FicSet" }
}
OnRevientDuBoulot
return progs............;
}
foreach Ligne [LesLignesDuFichier "/biolo/setbiolo.com"] {
set LesMots [LesMotsDuTexte $Ligne]
lassign $LesMots alias Alias Source FiCom
if {$Source != "source"} { continue }
set Dir [file dirname $FiCom]
if {[FileAbsent $Dir]} { Espionne "pas de dir pour" $Alias $Dir }
#continue
#Espionne $Alias $FiCom
if {[FileAbsent $FiCom]} { Espionne $Alias $FiCom }
}
return CleanBiolo
}
proc Curl url {
set Retour ""
package require TclCurl
::curl::transfer -url $url -followlocation 1 -bodyvar Retour
return $TextePDB
}
proc CleanRadarGenerator {{MiseAJour ""} {Force ""}} {
set MiseAJour [regexp -nocase M $MiseAJour]
set Force [regexp -nocase F $Force]
NousAllonsAuBoulot "/home/ripp/wwwLinux/gx/Transcriptomics/RadarGenerator"
set LesJetes {}
set LesModifs {}
foreach D [lsort [glob -nocomplain -type d *]] {
if {$D=="AJeter"} { continue }
if {[FileAbsent "$D/RadarMontage.php"]} { Espionne "$D/RadarMontage.php does not exist" ; continue }
set Texte [ContenuDuFichier "$D/RadarMontage.php"]
if {$MiseAJour && [regexp "www-bio3d-igbmc.u-strasbg.fr" $Texte]} {
if { ! $Force } { Affiche $Texte }
Garde "$D/RadarMontage.php"
if { ! [regexp "urlSite" $Texte]} {
regsub "//HTML" $Texte "\$urlSite = FedConfig::urlSite();\n\n//HTML" Texte
}
regsub -all -nocase {http://www-bio3d-igbmc.u-strasbg.fr/\~ripp/cgi-bin/gscope_html_server.tcsh\?EVImm&GeneIdentityCard&} $Texte "\$urlSite/phpRR/lance.php?action=GxFun::DisplayProbeset\\&ps=" Texte
regsub -all -nocase "mailto://Raymond.ripp@igbmc.u-strasbg.fr" $Texte "mailto://raymond.ripp@unistra.fr" Texte
regsub {window.location\(newUrl\}} $Texte " window.location(newUrl)" Texte
if { ! [regexp "AddFunctionalitiesToRadarMontage" $Texte]} {
regsub {\$doc->display} $Texte "\nGxFun::AddFunctionalitiesToRadarMontage(\$doc);\n\n&" Texte
}
if { ! $Force && [Affiche $Texte "AvecRetour"]==""} { exit }
Sauve $Texte dans "$D/RadarMontage.php"
lappend LesModifs "$D/RadarMontage.php"
}
if {[file exists "$D/RadarMontage1.png"]} { continue }
Espionne $D
exec mv $D "AJeter/"
lappend LesJetes $D
}
OnRevientDuBoulot
return [concat $LesJetes $LesModifs]
}
proc GQ {args} {
source "/home/ripp/wscoperr/genequid/genequid_proc.tcl"
return [GeneQuid {*}$args]
}
proc TTime {} {
set S "un deux trois"
Espionne [time {scan $S %s u} 1000]
Espionne [time {set u [string range $S 0 [string first " " $S]-1]} 1000]
return coucou
}
proc RenommeAlphabetic {} {
set LesF [lsort -dictionary [glob *]]
set LesTries {}
foreach F $LesF {
if {[regexp {([0-9]+)\.} $F Match N]} {
regsub {^0+} $N "" NOk
if {$N==""} { set N 0 }
regsub {([0-9]+)\.} $F [format "%3.3d" $NOk]. NewF
file rename -force $F $NewF
}
}
}
proc VerifInterproData {} {
set FicDat "/commun/banbi/InterPro/production/protein2ipr.dat"
set p2i [open $FicDat "r"]
set OldP ""
set C 0
set P ""
set I 0
while {1} {
set OldC $C
if {[gets $p2i Ligne]<0} { break }
incr I
set C [tell $p2i]
set NextC $C
scan $Ligne "%s" P
set Fin($P) $NextC
Espionne $C $OldP $P
lappend LesLignesDe($P) $Ligne
if {$OldP eq $P} { continue }
#rR on rencontre un nouveau P
set Deb($P) $OldC
#rR et donc on sauve l'ancien P
if {$OldP ne ""} {
set GQ [QuestionDeScience GeneQuid "ret InterproData $OldP"]
set TexteDe($OldP) [join $LesLignesDe($OldP) "\n"]
if {$TexteDe($OldP)!=$GQ} {
Espionne $TexteDe($OldP)
Espionne
Espionne $GQ
Espionne "oups pour $OldP en ligne $I $Deb($OldP) $Fin($OldP)"
FaireLire "oups pour $OldP en ligne $I"
}
lappend LesIndex "$OldP $Deb($OldP) $Fin($OldP)"
}
set OldP $P
}
close $p2i
lappend LesIndex "$OldP $Deb($OldP) $Fin($OldP)"
}
proc SnifAli {{Qui ""} {Quoi ""} {Ali ""}} {
global Zone
if {[info exists Zone($Qui,$Quoi)]} { return $Zone($Qui,$Quoi) }
if {$Ali==""} { set Ali "[PochAliDir]/FinalSansReste_Stras28_16h.tfa" }
regsub ".tfa" $Ali ".tclarray" Arr
if {[regexp "^ReLoad_" $Qui]} {
if {[file exists $Arr]} { file delete $Arr }
regsub "^ReLoad_" $Qui "" Qui
}
if {[file exists $Arr]} {
array set Zone [ContenuDuFichier $Arr]
} else {
set Zone(LesAccess,) {}
foreach Access [LaSequenceDuTFAs $Ali "LaListeDesAccess"] {
lappend Zone(LesAccess,) $Access
set Zone(Ligne,$Access) ""
set Seq [QueLaSequenceDuTexteTFA [LaSequenceDuTFAs $Ali $Access]]
set I 0
if { ! [info exists Zone(Width,)]} { set Zone(Width,) [string length $Seq] }
foreach A [split $Seq ""] {
lappend LesA $A
incr I
append Zone(Ligne,$Access) $A
if { ! [info exists Zone(Colonne,$I)]} { set Zone(Colonne,$I) "" }
append Zone(Colonne,$I) $A
}
}
set Zone(LesColonnes,) [NombresEntre 1 $Zone(Width,)]
set Zone(Height,) [llength $Zone(LesAccess,)]
set Zone(LesA,) [lsort -unique $LesA]
Sauve [array get Zone] dans $Arr
}
if {[info exists Zone($Qui,$Quoi)]} { return $Zone($Qui,$Quoi) }
if {$Qui=="StatAccess"} {
set N 0
set NN 0
set NS 0
set NZ 0
foreach Access $Zone(LesAccess,) {
incr N
if {[regexp "/" $Access]} { incr NS ; continue}
if {[regexp "_0$" $Access]} { incr NZ ; continue}
incr NN
}
return "$N $NN $NZ $NS"
}
if {$Qui=="seqlab"} {
regsub ".tfa" $Ali "" FicSeqlab
append FicSeqlab "_seqlab.png"
if {[FileAbsent $FicSeqlab]} {
#set Photo [image create photo -width 1001 -height 1001]
set Photo [image create photo -width $Zone(Width,) -height $Zone(Height,)]
set Y -1
set LesLignes {}
foreach Access [lrange $Zone(LesAccess,) 0 end] {
Espionne $Access
incr Y
set X -1
set LaLigne {}
foreach A [lrange [split $Zone(Ligne,$Access) ""] 0 end] {
incr X
lassign [LesCouleursSeqlabDesAAs $A hexa] F B
lappend LaLigne $B
}
lappend LesLignes $LaLigne
}
$Photo put $LesLignes -to 0 0
Espionne [$Photo get 50 50]
$Photo write $FicSeqlab -format png
}
return $FicSeqlab
}
if {$Qui=="colocal"} {
set NbSpot 20
regsub ".tfa" $Ali "" FicSeqlab
append FicColocal "_colocal.png"
if {[FileAbsent $FicColocal]} {
set Photo [image create photo -width $Zone(Width,) -height $NbSpot]
set X -1
set LesColonnes {}
foreach I [lrange $Zone(LesColonnes,) 0 end] {
set LaColonneColoree [ColCol $Zone(Colonne,$I) $NbSpot "HotSpot"]
if {$LaColonneColoree!=""} { Espionne [format "%4d %s" $I $LaColonneColoree] }
#$Photo put $LaColonneColoree -to $X 0 $X $NbSpot
}
#$Photo write $FicColocal -format png
}
return $FicColocal
}
if {[info exists Zone($Qui,$Quoi)]} { return $Zone($Qui,$Quoi) }
return "SnifAli done"
}
proc ColCol {Colonne NbSpot Type} {
set LesA [SnifAli LesA]
foreach A $LesA { set Cum($A) 0 }
foreach A [split $Colonne ""] {
incr Cum($A)
}
if {$Cum(-)>2000} { return "" }
set LaLigne {}
foreach A $LesA {
if {$Cum($A)<100} { set N " " } else { set N [format "%4d" $Cum($A)] }
lappend LaLigne [format "%s %s" $N $A]
}
set Ligne [join $LaLigne " "]
return $Ligne
}
#rR Olivier a foutu le souk dans ses alignements ... en fait c'est ordali qui a un bug.
#rR quand il groupait des séquences et le déplaçait les id ne suivaient pas !!!
#rR dans la suite Evo veut dire évolution des access, seq.
proc PochAliLaTotale {} {
#PochDegap
EvolAcc
EvolAccEtUniprot
EvolSeq
BonAliPourToday
}
proc EvolSeq {} {
set LaSortie {}
LConcat LaSortie [EvolSeqIT]
LConcat LaSortie [EvolSeqFT]
LConcat LaSortie [EvolSeqFI]
LConcat LaSortie [EvolSeqUT]
return $LaSortie
}
proc BonAliPourToday {} {
foreach Ligne [BonAccessPourToday] {
lassign [LesMotsDuTexte $Ligne] T BonT
if {$BonT!="."} { set Bon($T) $BonT }
}
set LeNew {}
foreach Ligne [LesLignesDuFichier "[PochAliDir]/gap_today.tfa"] {
if {[regexp ">" $Ligne]} {
regsub ">" $Ligne "" T
if {[info exists Bon($T)]} {
set Entete ">$Bon($T) remplace $T"
} else {
set Entete ">AFAIRE-$T"
}
lappend LeNew $Entete
continue
}
lappend LeNew $Ligne
}
return [SauveLesLignes $LeNew dans "[PochAliDir]/Repare.tfa"]
}
proc BonAccessPourToday {} {
set LaSortie {}
foreach Ligne [LesLignesDuFichier "[PochAliDir]/UniprotVersTodayEgares.txt"] {
lassign [LesMotsDuTexte $Ligne] Uniprot AC ID contient T
set BonT [TUT U-$AC]
if {$BonT==""} { set BonT "." }
lappend LaSortie [format "%-20s %-20s via %-20s" $T $BonT $AC]
}
return $LaSortie
}
proc TUT {{Qui ""} {Quoi ""}} {
global TUT
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists TUT($Qui,$Quoi)]} { return $TUT($Qui,$Quoi) }
if {[info exists TUT("EstCharge")]} { return "" }
set TUT("EstCharge") 1
set FichierEvolAcc "[PochAliDir]/EvolutionAccess.txt"
foreach Ligne [LesLignesDuFichier $FichierEvolAcc] {
lassign [LesMotsDuTexte $Ligne] Diff nF nI nT R egal F I T
set U $R
set TUT(T-$T,) $U
set TUT(U-$U,) $T
lappend TUT(LISTOF,T) $T
lappend TUT(LISTOF,U) $U
}
return [TUT $Qui $Quoi]
}
proc EvolAccEtUniprot {} {
set FichierEvolAcc "[PochAliDir]/EvolutionAccess.txt"
foreach Ligne [LesLignesDuFichier $FichierEvolAcc] {
lassign [LesMotsDuTexte $Ligne] Diff nF nI nT R egal F I T
set ACR [PU QY_$R AC]
set IDR [PU QY_$R ID]
set ACF [PU QY_$F AC]
set IDF [PU QY_$F ID]
set ACI [PU QY_$I AC]
set IDI [PU QY_$I ID]
set ACT [PU QY_$T AC]
set IDT [PU QY_$T ID]
set mAC [format "%3s %d %d %d %-20s = %-20s %-20s %-20s" $Diff $nF $nI $nT $ACR $ACF $ACI $ACT ]
set mID [format "%3s %d %d %d %-20s = %-20s %-20s %-20s" $Diff $nF $nI $nT $IDR $IDF $IDI $IDT ]
Espionne
Espionne $Ligne
Espionne $mAC
Espionne $mID
}
return EvolAccEtUniprot
}
proc VraimentEgares {} {
foreach Ligne [LesLignesDuFichier "[PochAliDir]/UniprotVersTodayEgares.txt"] {
lassign [LesMotsDuTexte $Ligne] U AC ID C Access
if {[regexp $Access "$AC $ID"]} { continue }
Espionne $Ligne
}
return brav
}
proc PA {{Qui ""} {Quoi ""}} {
global PA
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists PA($Qui,$Quoi)]} { return $PA($Qui,$Quoi) }
if {[info exists PA("EstCharge")]} { return "" }
set PA("EstCharge") 1
set First "[PochAliDir]/first.tfa"
set Inter "[PochAliDir]/inter.tfa"
set Today "[PochAliDir]/today.tfa"
foreach {X F} [list F $First I $Inter T $Today] {
set PA($X,FILE) $F
foreach {Entete Seq} [LesLignesDuFichier $F] {
if { ! [regexp {>([^ ]+)( |$)} $Entete Match Access]} { FaireLire "=$Entete=" }
set ACCESS [string toupper $Access]
set PA($ACCESS,ORI) $Access
lappend PA($X,LO) $Access
lappend PA($X,LA) $ACCESS
set PA($X,$ACCESS) $Seq
regsub {_.*$} $ACCESS "" REF
if {$REF!="YEAST"} {
set PA($ACCESS,REF) $REF
lappend PA($X,LORlof) $REF
lappend PA(LOR,) $REF
lappend PA($X-$REF,COPS) $ACCESS
}
if {[regexp {^.+_([^_]+)$} $ACCESS Match Fin]} {
if {[string length $Fin]>2} {
set PA($ACCESS,FIN) $Fin
lappend PA($X,LOF) $Fin
lappend PA(LOF,) $Fin
lappend PA($X-$Fin,FINS) $ACCESS
}
}
}
}
set PA(LOR,) [lsort -unique $PA(LOR,)]
return [PA $Qui $Quoi]
}
proc RecuperePU {LesNotFound} {
set LeR {}
set LesVraimentNotFound {}
foreach F $LesNotFound {
set Embl ""
foreach Cop [PA F-$F COPS] {
set Embl [QuestionDeScience ena::GeneQuid "ret UniprotData $Cop"]
set Embl [string trim $Embl]
if {$Embl!=""} { break }
if { ! [regexp {^([^_]+)_([^_]+)(_([^_]+))?$} $Cop Match Avant Apres Bidon Fin]} { continue }
set Embl [QuestionDeScience ena::GeneQuid "ret UniprotData $Apres"]
set Embl [string trim $Embl]
if {$Embl!=""} { break }
set Embl [QuestionDeScience ena::GeneQuid "ret UniprotData $Avant"]
set Embl [string trim $Embl]
if {$Embl!=""} { break }
set Embl [QuestionDeScience ena::GeneQuid "ret UniprotData ${Apres}_$Avant"]
set Embl [string trim $Embl]
if {$Embl!=""} { break }
set Embl [QuestionDeScience ena::GeneQuid "ret UniprotData ${Avant}_$Fin"]
set Embl [string trim $Embl]
if {$Embl!=""} { break }
}
if {$Embl==""} {
if {[PA F-$F FINS]!=""} {
set Fin [PA F-$F FINS]
lappend LesVraimentNotFound $F
if {[regexp {^([^_]+)_([^_]+)(_([^_]+))?$} $Fin Match Avant Apres Bidon FinFin]} {
set Embl [QuestionDeScience ena::GeneQuid "ret UniprotData $Apres"]
set Embl [string trim $Embl]
if {$Embl==""} {
set Embl [QuestionDeScience ena::GeneQuid "ret UniprotData $Avant"]
set Embl [string trim $Embl]
}
}
}
}
if {$Embl==""} {
#Espionne $F ******************* rien trouve;
set Embl "//"
}
lappend LeR "QY $F"
lappend LeR $Embl
}
return [list [join $LeR "\n"] $LesVraimentNotFound]
}
proc PU {{Qui ""} {Quoi ""}} {
global PU
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists PU($Qui,$Quoi)]} { return $PU($Qui,$Quoi) }
if {[info exists PU("EstCharge")]} { return "" }
set PU("EstCharge") 1
set FichierGQ "[PochAliDir]/gq.embl"
if {[file exists $FichierGQ]} {
set Embl [ContenuDuFichier $FichierGQ]
} else {
set LesAccess [PA LOR]
set Ids [join $LesAccess ","]
set Embl [QuestionDeScience ena::GeneQuid "ret UniprotData $Ids QY+"]
set LesAccess [PA LOF]
set Ids [join $LesAccess ","]
set Embl2 [QuestionDeScience ena::GeneQuid "ret UniprotData $Ids QY+"]
Sauve "$Embl\n$Embl2" dans $FichierGQ
}
set LesNotFound {}
set LesVraimentNotFound {}
foreach Pas [list Normal Recupere] {
#rR on tourne deux fois en changenat le Embl par appel de RecuperePU LesNotFound
set ID ""
set AC ""
set SQ ""
set DansSQ 0
foreach Ligne [split $Embl "\n"] {
if {[regexp {^QY ([^ ;]+)( |;|$)} $Ligne Match QY]} { continue }
if {[regexp {^ID ([^ ;]+)( |;|$)} $Ligne Match ID]} { continue }
if {[regexp {^AC ([^ ;]+)( |;|$)} $Ligne Match AC]} { continue }
if {[regexp {^SQ } $Ligne]} {
set DansSQ 1
set SQ ""
continue
}
if {[regexp {^//} $Ligne]} {
set DansSQ 0
set PU(QY_$QY,QY) $QY
set PU(QY_$QY,SQ) $SQ
set PU(QY_$QY,ID) $ID
set PU(QY_$QY,AC) $AC
set PU($AC,QY) $QY
set PU($AC,SQ) $SQ
set PU($AC,ID) $ID
set PU($AC,AC) $AC
set PU($ID,QY) $QY
set PU($ID,SQ) $SQ
set PU($ID,ID) $ID
set PU($ID,AC) $AC
lappend PU(LISTOF,QY] $QY
if {$AC==""} { lappend LesNotFound $QY }
if {$AC!=""} { lappend PU(LISTOF,AC) $AC }
if {$ID!=""} { lappend PU(LISTOF,ID) $ID }
set QY ""
set AC ""
set ID ""
set SQ ""
}
if {$DansSQ} {
set Ligne [string toupper $Ligne]
regsub -all {[^A-Z]} $Ligne "" Ligne
append SQ [string trim $Ligne]
continue
}
}
if {$Pas=="Normal"} {
set Retour [RecuperePU $LesNotFound]
lassign $Retour Embl LesVraimentNotFound
}
}
set PU(LISTOF,NOTFOUND) $LesVraimentNotFound
set FichierFastaUniprot "[PochAliDir]/uniprot.tfa"
if {[FileAbsent $FichierFastaUniprot]} {
set LeFasta {}
foreach AC $PU(LISTOF,AC) {
set ID $PU($AC,ID)
set SQ $PU($AC,SQ)
lappend LeFasta ">$AC $ID\n$SQ"
}
SauveLesLignes $LeFasta dans $FichierFastaUniprot
}
return [PU $Qui $Quoi]
}
proc EvolSeqUT {} {
set LesOk {}
set LesPerdus {}
set LesEgares {}
set ToutU [ContenuDuFichier "[PochAliDir]/uniprot.tfa"]
foreach T [PA T LA] {
set SeqT [PA T $T]
if {$SeqT==""} { continue }
set SeqPU [PU QY_T SQ]
if {[string first $SeqT $SeqPU]>=0} {
lappend LesOk [format "ok pour Today %-20s et Uniprot %-20s" $I]
continue
}
set PosU [string first $SeqT $ToutU]
if {$PosU<0} {
lappend LesPerdus "Today introuvable dans tout Uniprot : $T"
continue
}
set IdxU $PosU
set N 9999
while true {
if {[incr N -1]<0} { FaireLire "pas de chevron avant $PosU"; return "" }
incr IdxU -1
if {[string index $ToutU $IdxU]==">"} { break }
}
set AccessTrouve [string range $ToutU $IdxU+1 $PosU]
regsub {\n.*$} $AccessTrouve "" AccessTrouve
lappend LesEgares [format "Uniprot %-20s contient %-20s Today" $AccessTrouve $T]
}
set LaSortie {}
lappend LaSortie [SauveLesLignes $LesOk dans "[PochAliDir]/UniprotVersTodayOk.txt"]
lappend LaSortie [SauveLesLignes $LesPerdus dans "[PochAliDir]/UniprotVersTodaySupprimes.txt"]
lappend LaSortie [SauveLesLignes $LesEgares dans "[PochAliDir]/UniprotVersTodayEgares.txt"]
return $LaSortie
}
proc EvolSeqIT {} {
set ToutF [ContenuDuFichier [PA F file]]
set ToutI [ContenuDuFichier [PA I file]]
set ToutT [ContenuDuFichier [PA T file]]
set LesOk {}
set LesPerdus {}
set LesEgares {}
foreach R [PA LOR] {
set SesF [PA F-$R COPS] ; set nF [llength $SesF]
set SesI [PA I-$R COPS] ; set nI [llength $SesI]
set SesT [PA T-$R COPS] ; set nT [llength $SesT]
set F [lindex $SesF 0]
set I [lindex $SesI 0]
set T [lindex $SesT 0]
set SeqF [PA F $F]
set SeqI [PA I $I]
set SeqT [PA T $T]
if {$T==""} { continue }
if {[string first $SeqT $SeqI]>=0} {
lappend LesOk [format "ok pour Today %-20s et Inter %-20s" $I $F]
continue
}
set PosI [string first $SeqT $ToutI]
if {$PosI<0} {
lappend LesPerdus "Today introuvable dans tout Inter : $T"
continue
}
set IdxI $PosI
set N 9999
while true {
if {[incr N -1]<0} { FaireLire "pas de chevron avant $PosI"; return "" }
incr IdxI -1
if {[string index $ToutI $IdxI]==">"} { break }
}
set AccessTrouve [string range $ToutI $IdxI+1 $PosI]
regsub {\n.*$} $AccessTrouve "" AccessTrouve
lappend LesEgares [format "Inter %-20s contient %-20s Today" $AccessTrouve $T]
}
set LaSortie {}
lappend LaSortie [SauveLesLignes $LesOk dans "[PochAliDir]/InterVersTodayOk.txt"]
lappend LaSortie [SauveLesLignes $LesPerdus dans "[PochAliDir]/InterVersTodaySupprimes.txt"]
lappend LaSortie [SauveLesLignes $LesEgares dans "[PochAliDir]/InterVersTodayEgares.txt"]
return $LaSortie
}
proc EvolSeqFT {} {
set ToutF [ContenuDuFichier [PA F file]]
set ToutI [ContenuDuFichier [PA I file]]
set ToutT [ContenuDuFichier [PA T file]]
set LesOk {}
set LesPerdus {}
set LesEgares {}
foreach R [PA LOR] {
set SesF [PA F-$R COPS] ; set nF [llength $SesF]
set SesI [PA I-$R COPS] ; set nI [llength $SesI]
set SesT [PA T-$R COPS] ; set nT [llength $SesT]
set F [lindex $SesF 0]
set I [lindex $SesI 0]
set T [lindex $SesT 0]
set SeqF [PA F $F]
set SeqI [PA I $I]
set SeqT [PA T $T]
if {$T==""} { continue }
if {[string first $SeqT $SeqF]>=0} {
lappend LesOk [format "ok pour Today %-20s et First %-20s" $I $F]
continue
}
set PosF [string first $SeqT $ToutF]
if {$PosF<0} {
lappend LesPerdus "Today introuvable dans tout First : $T"
continue
}
set IdxF $PosF
set N 9999
while true {
if {[incr N -1]<0} { FaireLire "pas de chevron avant $PosF"; return "" }
incr IdxF -1
if {[string index $ToutF $IdxF]==">"} { break }
}
set AccessTrouve [string range $ToutF $IdxF+1 $PosF]
regsub {\n.*$} $AccessTrouve "" AccessTrouve
lappend LesEgares [format "First %-20s contient %-20s Today" $AccessTrouve $T]
}
set LaSortie {}
lappend LaSortie [SauveLesLignes $LesOk dans "[PochAliDir]/FirstVersTodayOk.txt"]
lappend LaSortie [SauveLesLignes $LesPerdus dans "[PochAliDir]/FirstVersTodaySupprimes.txt"]
lappend LaSortie [SauveLesLignes $LesEgares dans "[PochAliDir]/FirstVersTodayEgares.txt"]
return $LaSortie
}
proc EvolSeqFI {} {
set ToutF [ContenuDuFichier [PA F file]]
set ToutI [ContenuDuFichier [PA I file]]
set ToutT [ContenuDuFichier [PA T file]]
set LesOk {}
set LesPerdus {}
set LesEgares {}
foreach R [PA LOR] {
set SesF [PA F-$R COPS] ; set nF [llength $SesF]
set SesI [PA I-$R COPS] ; set nI [llength $SesI]
set SesT [PA T-$R COPS] ; set nT [llength $SesT]
set F [lindex $SesF 0]
set I [lindex $SesI 0]
set T [lindex $SesT 0]
set SeqF [PA F $F]
set SeqI [PA I $I]
set SeqT [PA T $T]
if {$I==""} { continue }
if {[string first $SeqI $SeqF]>=0} {
lappend LesOk [format "ok pour Inter %-20s et First %-20s" $I $F]
continue
}
set PosF [string first $SeqI $ToutF]
if {$PosF<0} {
lappend LesPerdus "Inter introuvable dans tout First : $I"
continue
}
set IdxF $PosF
set N 9999
while true {
if {[incr N -1]<0} { FaireLire "pas de chevron avant $PosF"; return "" }
incr IdxF -1
if {[string index $ToutF $IdxF]==">"} { break }
}
set AccessTrouve [string range $ToutF $IdxF+1 $PosF]
regsub {\n.*$} $AccessTrouve "" AccessTrouve
lappend LesEgares [format "First %-20s contient %-20s Inter" $AccessTrouve $I]
}
set LaSortie {}
lappend LaSortie [SauveLesLignes $LesOk dans "[PochAliDir]/FirstVersInterOk.txt"]
lappend LaSortie [SauveLesLignes $LesPerdus dans "[PochAliDir]/FirstVersInterSupprimes.txt"]
lappend LaSortie [SauveLesLignes $LesEgares dans "[PochAliDir]/FirstVersInterEgares.txt"]
return bravo
}
proc EvolAcc {} {
set LesF [lsort [PA F LA]]
set LesI [lsort [PA I LA]]
set LesT [lsort [PA T LA]]
set LesR [PA LOR]
set LesDoublons {}
foreach R $LesR {
set SesF [PA F-$R COPS] ; set nF [llength $SesF]
set SesI [PA I-$R COPS] ; set nI [llength $SesI]
set SesT [PA T-$R COPS] ; set nT [llength $SesT]
set F [lindex $SesF 0]
set I [lindex $SesI 0]
set T [lindex $SesT 0]
set Diff ". "
if {$nF!=1 || $nI!=1 || $nT!=1} { set Diff "***" }
if {$F==""} { set F "." }
if {$I==""} { set I "." }
if {$T==""} { set T "." }
set Ligne [format "%s %d %d %d %-20s = %-20s %-20s %-20s" $Diff $nF $nI $nT $R $F $I $T ]
if {$nF>1} { append Ligne " F+[join $SesF /]"}
if {$nI>1} { append Ligne " I+[join $SesI /]"}
if {$nT>1} { append Ligne " T+[join $SesT /]"}
if {$nF>1 && [llength [lsort -unique $SesF]]!=$nF} { lappend LesDoublons "F $SesT" }
if {$nI>1 && [llength [lsort -unique $SesI]]!=$nI} { lappend LesDoublons "I $SesI" }
if {$nT>1 && [llength [lsort -unique $SesT]]!=$nT} { lappend LesDoublons "T $SesT" }
lappend LaSortie $Ligne
}
set LesF [PA LOF] ; #rR attention LOF pas LOR
set LesDoublons {}
foreach R $LesF {
set SesF [PA F-$R FINS] ; set nF [llength $SesF]
set SesI [PA I-$R FINS] ; set nI [llength $SesI]
set SesT [PA T-$R FinS] ; set nT [llength $SesT]
set F [lindex $SesF 0]
set I [lindex $SesI 0]
set T [lindex $SesT 0]
set Diff ". "
if {$nF!=1 || $nI!=1 || $nT!=1} { set Diff "***" }
if {$F==""} { set F "." }
if {$I==""} { set I "." }
if {$T==""} { set T "." }
set Ligne [format "%s %d %d %d %-20s = %-20s %-20s %-20s" $Diff $nF $nI $nT $R $F $I $T ]
if {$nF>1} { append Ligne " F+[join $SesF /]"}
if {$nI>1} { append Ligne " I+[join $SesI /]"}
if {$nT>1} { append Ligne " T+[join $SesT /]"}
if {$nF>1 && [llength [lsort -unique $SesF]]!=$nF} { lappend LesDoublons "F $SesT" }
if {$nI>1 && [llength [lsort -unique $SesI]]!=$nI} { lappend LesDoublons "I $SesI" }
if {$nT>1 && [llength [lsort -unique $SesT]]!=$nT} { lappend LesDoublons "T $SesT" }
lappend LaSortie $Ligne
}
SauveLesLignes $LesDoublons dans "[PochAliDir]/Doublons.txt"
SauveLesLignes $LaSortie dans "[PochAliDir]/EvolutionAccess.txt"
}
proc PochAliDir {} {
return "/home/ripp/pochali"
}
proc PochDegap {} {
NousAllonsAuBoulot [PochAliDir]
foreach F [glob -nocomplain "gap_*.tfa"] {
set LeNew {}
set Seq ""
foreach Ligne [LesLignesDuFichier $F] {
if {[regexp "^>" $Ligne]} {
if {$Seq!=""} { lappend LeNew $Seq }
set Seq ""
lappend LeNew $Ligne
continue
}
set Ligne [string toupper $Ligne]
regsub -all {[^A-Z]} $Ligne "" Ligne
append Seq $Ligne
}
lappend LeNew $Seq
regsub "^gap_" $F "" N
SauveLesLignes $LeNew dans $N
Espionne $N
}
OnRevientDuBoulot
}
proc CompareLesFortran {{Ici ""} {La ""}} {
foreach F [lsort ] {
}
}
proc Mesures {} {
set LesLignes [LesLignesDuFichier "/home/ripp/www/chore/Mesures.txt"]
scan [lindex $LesLignes end] "%s %s %s" PH PA PZ
set T 0
foreach Ligne $LesLignes {
scan $Ligne "%s %s %s" H A Z
set D [expr $A-$PA]
if {$D<0} { set D [expr $D+360] }
Espionne "$H $D"
set PA $A
set T [expr $T + $D]
}
return $T
}
proc AngleDesTemps {T1 T2 {Latitude ""} {Longitude ""} {DecalageHoraire ""}} {
set D1 [AngleDeHeure $T1 $Latitude $Longitude $DecalageHoraire]
set D2 [AngleDeHeure $T2 $Latitude $Longitude $DecalageHoraire]
Espionne D1 $D1 D2 $D2 $D2-$D1
set D [expr $D1-$D2]
return $D
}
proc AngleDeHeure {T {Latitude ""} {Longitude ""} {DecalageHoraire ""}} {
set PI 3.141592
if {$DecalageHoraire==""} { set DecalageHoraire 2 }
set DecalageAngulaire [expr $DecalageHoraire*15]
if {[regexp {^([0-9]+)$} $T]} { append T ":00" }
if {[regexp {^([0-9]+)\:([0-9]+)$} $T]} { append T ":00" }
if {[regexp {^([0-9]+)\:([0-9]+)\:([0-9]+)$} $T Match H M S]} {
set T [expr (($H*15*60*60+$M*60*15+$S*15)/3600.)]
}
if {$Latitude==""} { set Latitude "48° 43' 7.673'' N" }
if {$Longitude==""} { set Longitude "7° 19' 56.69'' E" }
set Longitude 7.332414
#set Longitude 0
set Latitude 48.718798
set TempsSolaire [expr $T-$DecalageAngulaire+$Longitude]
if {$TempsSolaire<0} { set TempsSolaire [expr $TempsSolaire+360] }
set Compression [expr cos($Latitude*$PI/180.)]
set TempsCartesien [expr 270 - $TempsSolaire]
if {$TempsCartesien<0} { set TempsCartesien [expr $TempsCartesien+360] }
set A [expr $TempsCartesien*$PI/180]
Espionne A $A
set SA [expr sin($A)]
set CA [expr cos($A)]
Espionne $SA $CA
set SAC [expr $SA*$Compression]
set X [expr atan2($SAC,$CA)]
set AngleOmbre [expr 90-$X*180./$PI]
Espionne $T AngleOmbre $AngleOmbre
return $AngleOmbre
}
proc BBSAnnotLaTotale {} {
#rR setgscoperr BBSAnnot (repondre Yes pour créer le rep
#rR cd /genomics/Link/BBSAnnot
#rR mkdir DeOlivier
#rR copier les *_Kir.tfa de /home/poch/... dans DeOlivier/
#rR gscope puts BBSDeOlivier
#rR maintenant on a le UniprotId.txt qui permet de créer le projet gscope
#rR setgscoperr
#rR gscope ........................... repondre en donnant le UniprotId.txt come fof
#rR gscope puts BBSCreateOrthologs
#rR gscope puts BBSCreateAccessMRnaPourTous
#rR on peut maintenant faire
#rR gscope puts MRna ListOf Nom
#rR gscope puts MRna BBS01 ListOfHomo
#rR gscope puts MRna P12345 prottfa
}
proc BBSCreateAccessMRnaPourTous {} {
foreach Nom [ListeDesPABs] {
set FicOri "[RepertoireDuGenome]/AccessMrnaOri/$Nom.mgs"
set Fic "[RepertoireDuGenome]/AccessMrna/$Nom"
file copy -force $FicOri $Fic
set Embl [ContenuDuFichier [GscopeFile $Nom protembl]]
if { ! [regexp {AC ([^;]+);} $Embl Match Access]} { Espionne $Embl; FaireLire "$Nom sans AC" }
InformeSansDemander $Nom "AC: $Access"
}
}
proc BBSCreateOrthologs {} {
set RepOrthologs "[RepertoireDuGenome]/orthologs"
file mkdir $RepOrthologs
set LaSortie {}
foreach Nom [ListeDesPABs] {
set MesCopains {}
foreach Id [LaSequenceDuTFAs [GscopeFile $Nom "tfasdescopainsOlivier"] "LaListeDesAccess"] {
set Access [GeneQuid UniprotData $Id "AC"]
regsub {;.*} $Access "" Access
#Espionne $Id $Access
if {$Access==""} { set Access $Id }
lappend MesCopains $Access
}
lappend LaSortie [SauveLesLignes $MesCopains dans "$RepOrthologs/$Nom"]
}
return $LaSortie
}
proc BBSDeOlivier {} {
#rR On lit les alignements au format TFA de Olivier
#rR ils sont de la forme BBSx_GeneName_abcdef.tfa ou BBSxy_abcdef.tfa si le BBSxy est le nom du gène.
#rR on cherche dans le fichier .tfa le _HUMAN pour avoir le UniprotId
#rR on stocke les .tfa dans tfasdescopainsOlivier.BBSxy
#rR on crée la liste des UniprotId qui servira à créer le projet.
set Rep "/genomics/link/BBSAnnot"
set RepTfaOlivier "$Rep/tfasdescopainsOlivier"
file mkdir $RepTfaOlivier
set RepProtEmb "$Rep/protembl"
file mkdir $RepProtEmb
NousAllonsAuBoulot "$Rep/DeOlivier"
set LesNom {}
foreach F [glob -nocomplain "*_Kir.tfa"] {
if {[regexp {^([^_]+)_([^_]+)_(.*)$} $F Match N G S]} {
} elseif {[regexp {^([^_]+)_(.*)$} $F Match G S]} {
set N $G
} else {
FaireLire "Ca merde pour $F"
}
Espionne $N / $G / $S
regsub BBS $N "" N
set Nom [format %s%2.2d "BBS" $N]
Espionne $Nom
file copy -force $F $RepTfaOlivier/$Nom
lappend LesNoms $Nom
if { ! [regexp {>([^_]+_HUMAN)} [ContenuDuFichier $F] Match GeneLu]} { FaireLire "Trouve pas _HUMAN dans $F" }
if {$GeneLu!="${G}_HUMAN"} { Espionne "$GeneLu!=${G}_HUMAN" }
set UniprotId($Nom) $GeneLu
}
Sauve [array get UniprotId] dans "UniprotId.txt"
set LesNoms [lsort $LesNoms]
foreach Nom $LesNoms {
set G $UniprotId($Nom)
set F $RepTfaOlivier/$Nom
set Embl [SequenceDesBanques $G "OnVeutEmbl"]
Espionne $Nom
Espionne [string length $Embl]
#Sauve $Embl dans $RepProtEmb/$Nom
lappend LesUniprotId $G
}
SauveLesLignes $LesUniprotId dans "LesUniprotId.txt"
OnRevientDuBoulot
return $LesUniprotId
}
proc XMotifInRna {{Qui ""} {Quoi ""}} {
set Quoi [string tolower $Quoi]
global XMotifInRna
if {[info exists XMotifInRna($Qui,$Quoi)]} { return $XMotifInRna($Qui,$Quoi) }
if {[info exists XMotifInRna("EstCharge")]} { return "" }
set XMotifInRna("EstCharge") 1
set Fichier "/home/ripp/3d/XMotifInRna.csv"
LoadTxl $Fichier XMotifInRna -1 "\t"
set XMotifInRna(ListOf,index) $XMotifInRna(ListOf,Index)
set XMotifInRna(ListOf,header) $XMotifInRna(ListOf,Header)
foreach I $XMotifInRna(ListOf,Index) {
set Motif $XMotifInRna($I,XMotif)
set XMotifInRna($Motif,motif) $Motif
foreach K $XMotifInRna(ListOf,Header) {
set V $XMotifInRna($I,$K)
regsub "’" $V "p" V
Espionne $V
set XMotifInRna($Motif,$K) $V
}
lappend XMotifInRna(ListOf,motif) $Motif
if {[regexp "m" $Motif]} {
lappend XMotifInRna(ListOf,16smotif) $Motif
} else {
lappend XMotifInRna(ListOf,23smotif) $Motif
}
}
return [XMotifInRna $Qui $Quoi]
}
proc ContactRna16SWithMrna {} {
set LesPosB [list 518C 530G 789U 926G 927G 1054C 1195C 1196U 1397C 1398A 1399. 1400C 1401G 1402C 1403C 1492A 1493A 1494G 1495. 1496. 1497G 1498U 1503A 1504G 1505G 1506U 1507A ]
set PreviousPos -99
set PreviousB ""
set Debut [lindex $LesPosB 0]
set CurrentSeq ""
set LesPosSeq {}
lappend LesPosB 999999.
foreach PosB $LesPosB {
regsub -all U $PosB T PosB
regexp {^([0-9]+)([ATGC\.])$} $PosB Match Pos B
if {$PreviousPos+1!=$Pos} {
if {$PreviousPos>=0} { lappend LesPosSeq "$Debut $PreviousPos $CurrentSeq" }
set CurrentSeq ""
set Debut $Pos
}
append CurrentSeq $B
set PreviousPos $Pos
}
return $LesPosSeq
}
proc XMotifsInOverlap {{Qui ""} {Quoi ""}} {
global XMotifsInOverlap
if {[info exists XMotifsInOverlap($Qui,$Quoi)]} { return $XMotifsInOverlap($Qui,$Quoi) }
if {[info exists XMotifsInOverlap("EstCharge")]} { return "" }
set XMotifsInOverlap("EstCharge") 1
#set ListOfSizeOrSeq [OverlapTU ListOf SizeOver]
set ListOfSizeOrSeq $Qui
set Extend 12
set NbHits 0
foreach Insert [list "" N NN NNN] {
set LesI {}
if {[info exists Cumul]} { unset Cumul }
foreach SS $ListOfSizeOrSeq {
foreach LRSS [OverlapTU $SS Names] {
scan $LRSS "%s %s %s %s" L R SizeOver SeqOver
set LocL [ExtraitInfo $L "location:"]
if { ! [regexp {^([0-9]+)\.\.([0-9]+)$} $LocL Match DL FL]} { continue }
set LocR [ExtraitInfo $R "location:"]
if { ! [regexp {^([0-9]+)\.\.([0-9]+)$} $LocR Match DR FR]} { continue }
incr DR 98
#set Seq [BoutADN [expr $DR-9] [expr $FL+9]]
set Seq "[BoutADN [expr $DR-$Extend] $DR]$Insert[BoutADN [expr $DR+1] [expr $DR+$Extend]]"
incr NbSeq
if {[regexp "T.GCG|GCG.T|A.CGC|CGC.A" $Seq]} { incr NbHits }
#Espionne $Seq
foreach Frame $Quoi {
set LesNCL [XMotifs $Seq $Frame 2 2]
foreach {NC L} $LesNCL {
foreach DF $L {
lassign [split $DF " "] D F
foreach I [NombresEntre $D $F] {
incr Cumul($I)
lappend LesI $I
}
}
}
}
}
}
set LesI [lsort -unique -integer $LesI]
Espionne
foreach I $LesI {
Espionne [format "%4d %s %s" [expr $I-$Extend] [string repeat "*" $Cumul($I)] $Insert]
}
}
Espionne $NbHits / $NbSeq
}
proc Xmotifs16SInOverlap {{ListOfSizeOrSeq ""}} {
if {$ListOfSizeOrSeq==""} { set ListOfSizeOrSeq [OverlapTU ListOf SizeOver] }
foreach SS $ListOfSizeOrSeq {
foreach LRSS [OverlapTU $SS Names] {
scan $LRSS "%s %s %s %s" L R SizeOver SeqOver
set HitsL [lsort -unique [HasXMotif16S $L ListOfHits]]
set HitsR [lsort -unique [HasXMotif16S $R ListOfHits]]
Espionne $LRSS\n\t\t\t\t\t$HitsL\n\t\t\t\t\t$HitsR
}
}
exit
}
proc OverlapTU {{Qui ""} {Quoi ""}} {
global OverlapTU
if {[info exists OverlapTU($Qui,$Quoi)]} { return $OverlapTU($Qui,$Quoi) }
if {[info exists OverlapTU("EstCharge")]} { return "" }
set OverlapTU("EstCharge") 1
set ADN [ContenuDuFichier "[RepertoireDuGenome]/beton/adn"]
set ADN "n[string toupper $ADN]"
set Debordement 39
foreach TU [TU ListOf TU] {
if {[TU $TU NbOfGenesInTU]<2} { continue }
set GenesInTUC [TU $TU ListOfNom]
set Reverse 0
if {[TU $TU StrandDirection]=="-"} { set Reverse 1 }
if {$Reverse} { set GenesInTUC [lreverse $GenesInTUC] }
foreach L [lrange $GenesInTUC 0 end-1] R [lrange $GenesInTUC 1 end] {
if {$Reverse} {continue}
set LocL [ExtraitInfo $L "location:"]
if { ! [regexp {^([0-9]+)\.\.([0-9]+)$} $LocL Match DL FL]} { continue }
set LocR [ExtraitInfo $R "location:"]
if { ! [regexp {^([0-9]+)\.\.([0-9]+)$} $LocR Match DR FR]} { continue }
set SizeOver [expr $FL-$DR+1]
incr FL 98
incr DR 98
if {$SizeOver<1} { continue }
#Espionne
#Espionne $L $LocL $R $LocR $SizeOver
#Espionne FL $FL DR $DR $FL-$DR $SizeOver
set Fin [string range $ADN $FL-$Debordement $FL+2]
set Deb [string range $ADN $DR+2 [expr $DR+$Debordement]]
set Decal [string repeat " " [expr $Debordement-$SizeOver+3]]
#Espionne $Fin
#Espionne $Decal$Deb [string range $Deb 0 $SizeOver-1]
#Espionne [string range [QueLaSequenceDuFichierTFA [GscopeFile $L nuctfa]] end-20 end]
#Espionne [string range [QueLaSequenceDuFichierTFA [GscopeFile $R nuctfa]] 0 20]
set SeqOver [string range $Deb 0 $SizeOver-1]
lappend OverlapTU($SizeOver,Names) "$L $R $SizeOver $SeqOver"
lappend OverlapTU($SeqOver,Names) "$L $R $SizeOver $SeqOver"
lappend OverlapTU($SizeOver,ListOfSeqOver) $SeqOver
lappend OverlapTU(ListOf,SizeOver) $SizeOver
incr OverlapTU($SeqOver,Nb)
}
}
set OverlapTU(ListOf,SizeOver) [lsort -unique -integer $OverlapTU(ListOf,SizeOver)]
foreach SizeOver $OverlapTU(ListOf,SizeOver) {
set OverlapTU($SizeOver,ListOfSeqOver) [lsort -unique $OverlapTU($SizeOver,ListOfSeqOver)]
foreach SeqOver $OverlapTU($SizeOver,ListOfSeqOver) {
lappend OverlapTU(ListOf,SeqOver) $SeqOver
}
}
return [OverlapTU $Qui $Quoi]
}
proc HasXMotif16S {{Qui ""} {Quoi ""}} {
global HasXMotif16S
if {[info exists HasXMotif16S($Qui,$Quoi)]} { return $HasXMotif16S($Qui,$Quoi) }
if {[info exists HasXMotif16S("EstCharge")]} { return "" }
set HasXMotif16S("EstCharge") 1
set HitsFiles [lsort [glob "[RepertoireDuGenome]/XMotifsRNA16S/XMotif_F*.hits"]]
#set HitsFiles [list "[RepertoireDuGenome]/XMotifsRNA16S/XMotif_F_0517-0525.hits"]
#set HitsFiles [list "[RepertoireDuGenome]/XMotifsRNA16S/XMotif_F_1397-1403.hits"]
foreach File $HitsFiles {
set Queue [file tail $File]scan $NNSS "%s %s %s %s" L R SizeOver SeqOver
regsub ".txt" $Queue "" Queue
foreach Ligne [LesLignesDuFichier $File] {
scan $Ligne "%s %s %s %s %s %s %s %s" a b c d e f g Nom
lappend HasXMotif16S(ListOf,Yes) $Nom
set HasXMotif16S($Nom,) 1
set HasXMotif16S($Nom,Color) green
lappend HasXMotif16S($Queue,ListOfYes) $Nom
lappend HasXMotif16S($Nom,ListOfHits) $Queue
}
}
set HasXMotif16S(ListOf,Yes) [lsort -unique $HasXMotif16S(ListOf,Yes)]
foreach Nom [ListeDesPABs] {
if {[info exists HasXMotif16S($Nom,)]} { continue }
lappend HasXMotif16S(ListOf,No) $Nom
set HasXMotif16S($Nom,) 0
set HasXMotif16S($Nom,Color) lightblue
}
return [HasXMotif16S $Qui $Quoi]
}
proc HasXMotif {{Qui ""} {Quoi ""}} {
global HasXMotif
if {[info exists HasXMotif($Qui,$Quoi)]} { return $HasXMotif($Qui,$Quoi) }
if {[info exists HasXMotif("EstCharge")]} { return "" }
set HasXMotif("EstCharge") 1
foreach Nom [ListeDesPABs] {
set Liste [XMotifs $Nom 0 8 2]
if {$Liste=={}} {
Espionne $Nom
lappend HasXMotif(ListOf,No) $Nom
set HasXMotif($Nom,) 0
set HasXMotif($Nom,Color) lightblue
} else {
lappend HasXMotif(ListOf,Yes) $Nom
set HasXMotif($Nom,) 1
set HasXMotif($Nom,Color) green
}
}
return [HasXMotif $Qui $Quoi]
}
proc WithXColumn Nom {
set WXM [ExtraitInfo $Nom "WithXColumn:"]
if {$WXM==""} { return 0 }
return 1
}
proc TU {{Qui ""} {Quoi ""}} {
global TU
if {[info exists TU($Qui,$Quoi)]} { return $TU($Qui,$Quoi) }
if {[info exists TU("EstCharge")]} {
if {[EstUnPAB $Qui]} {
set B [ExtraitInfo $Qui "locus_tag"]
return [TU $B $Quoi]
}
return ""
}
set TU("EstCharge") 1
set Fichier "[RepertoireDuGenome]/fiches/OperonEcoliMao.csv"
LoadTxlWithRowsOfCells $Fichier TU 0 ";"
set TU(ListOf,Header) $TU(ListHeaderPlease,)
set TU(ListOf,Index) $TU(ListAllPlease,)
#Espionne $TU(ListOf,Index)
#EspionneL $TU(ListOf,Header)
set ColorRamp(+) [list red orange]
set ColorRamp(-) [list green blue]
set ColorSolo white
set IColorRamp(+) 0
set IColorRamp(-) 0
foreach I $TU(ListOf,Index) {
set LesGenes [split $TU($I,GenesInTUC) ","]
set Skip 0
set KeepedGenes {}
foreach B $LesGenes {
if {[info exists TU($B,TU)]} { set Skip 1 ; break }
lappend KeepedGenes $B
}
if {$Skip} { set TU($I,Skipped) 1; lappend TU(ListOf,Skipped) $I; continue }
set TU($I,Skipped) 0
set Sens $TU($I,StrandDirection)
set Ieme -1
if {[set NbOfGenesInTU [llength $KeepedGenes]]>1} { set Ieme 0 ; incr IColorRamp($Sens); lappend TU(ListOf,TU) $I}
set TU($I,NbOfGenesInTU) $NbOfGenesInTU
set Prefixe [PreFixe]
foreach B $KeepedGenes {
incr Ieme
lappend TU(ListOf,Gene) $B
set TU($B,Sens) $Sens
set TU($B,TU) $I
set TU($B,Ieme) $Ieme
set TU($B,NbOfGenesInTU) $NbOfGenesInTU
if {$NbOfGenesInTU==1} {
set TU($B,Color) $ColorSolo
} else {
set TU($B,Color) [lindex $ColorRamp($Sens) [expr $IColorRamp($Sens)%[llength $ColorRamp($Sens)]]]
}
regsub "b" $B $Prefixe Nom
lappend TU($I,ListOfNom) $Nom
}
}
return [TU $Qui $Quoi]
}
proc BlastXmotifsFromRNA16S {} {
set Banque "[RepertoireDuGenome]/banques/AllNuctfa"
set RepXMotifs "[RepertoireDuGenome]/XMotifsRNA16S"
file mkdir $RepXMotifs
set DoBlast 0
set WithGrep 0
set SeqRNA16S [QueLaSequenceDuFichierTFA [GscopeFile rRNA-16S nuctfa]]
set LesFichiersHits {}
foreach Ligne [LesLignesDuFichier [Fiches "XMotifsRNA16S_limits.txt"]] {
lassign [split $Ligne "-"] D F
regsub {^0+} $D "" D
regsub {^0+} $F "" F
Espionne $Ligne $D $F
set SeqXMotifF "[string range n$SeqRNA16S $D $F]"
set SeqXMotifR [NucToReverseAndComplementNuc $SeqXMotifF]
if {$DoBlast} {
set TFA [SequenceFormatTFA $SeqXMotif "$Filename.tfa" "nucbrut"]
set FichierQuery "$RepXMotifs/$Filename.tfa"
Sauve $TFA dans $FichierQuery
set FichierBlast $FichierQuery
regsub {\.tfa$} $FichierBlast "" FichierBlast
append FichierBlast ".blast"
exec blastall -p blastn -d $Banque -i $FichierQuery -F F -o $FichierBlast -W 4
Espionne "$FichierBlast done"
} elseif {$WithGrep} {
foreach Sens {F R} {
set LesHits {}
set SeqQuery [set SeqXMotif$Sens]
set Filename "XMotif${Sens}_$D-$F"
set FichierHits "$RepXMotifs/$Filename.hits"
foreach Nom [ListeDesPABs] {
set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom nuctfa]]
if {[string first $SeqQuery $Seq]<0} { continue }
set Product [ExtraitInfo $Nom "Product:"]
lappend LesHits "$SeqQuery $Nom $Product"
Espionne "$SeqQuery $Nom $Product"
}
if {$LesHits!={}} {
lappend LesFichiersHits [SauveLesLignes $LesHits dans $FichierHits]
}
}
} else {
foreach Sens {F R} {
set SeqQuery [set SeqXMotif$Sens]
set Filename "XMotif_${Sens}_[format %4.4d $D]-[format %4.4d $F]"
set FichierHits "$RepXMotifs/$Filename.hits"
set LesHits {}
foreach Nom [ListeDesPABs] {
set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom nuctfa]]
foreach {NC ListOfDF} [XMotifs $Seq 0 2 1] {
lassign [split $NC ","] N C
foreach DFx $ListOfDF {
lassign [split $DFx " "] Dx Fx
set F2x [expr $Fx+2]
set SeqFound [string range $Seq $Dx $F2x]
if {[string first $SeqFound $SeqQuery]<0} { continue }
set Product [ExtraitInfo $Nom "Product:"]
set Message "$Sens $SeqQuery $SeqFound [format {%4d %4d} $Dx $F2x] $N $C $Nom $Product"
Espionne $Message
lappend LesHits $Message
}
}
}
if {$LesHits!={}} {
lappend LesFichiersHits [SauveLesLignes $LesHits dans $FichierHits]
}
}
}
}
return $LesFichiersHits
}
proc FromChro {{Qui ""} {Quoi ""}} {
set Coin 999
#rR On a des chromosomes qu'on veut mettre bout à bout avec une zone de $Coin n entre chaque
#rR c'est comme si on avait un immense chromosome.
#rR pour Chr07-123456 on veut la position globale comme s'il y avait les 6 chr avant et les offsets de 999 n
#rR et reciproquement
#rR Attention on enleve qussi les run de N en debut et en fin : N5 N5 de longuer L5 L3
global FromChro
if {[info exists FromChro($Qui,$Quoi)]} { return $FromChro($Qui,$Quoi) }
if {[info exists FromChro("EstCharge")]} {
if {[regexp {^(Chr[0-9]+)\-([0-9]+)$} $Qui Match Chr Pos]} {
if {$Quoi=="DispPos" && [info exists FromChro($Chr,DispStart)]} { return [expr $FromChro($Chr,DispStart) + $Pos] }
}
if {[regexp {^[0-9]+$} $Qui]} {
if {[info exists [info exists FromChro($Quoi,DispStart)]]} { return [expr $Qui - $FromChro($Chr,DispStart)] }
}
return ""
}
set FromChro("EstCharge") 1
set ChroDir [RepertoireDuGenome]
regsub {(Chr|CDS)$} $ChroDir "Chr" ChroDir
set ChroNucDir "$ChroDir/nuctfa"
set MemoFile "$ChroDir/fiches/MemoFromChro.txt"
if {[file exists $MemoFile]} {
array set FromChro [ContenuDuFichier $MemoFile]
return [FromChro $Qui $Quoi]
}
set LesFicTfaChr [lsort [glob -nocomplain $ChroNucDir/*Chr*]]
set DispStop 0
foreach FicTfaChr $LesFicTfaChr {
set Queue [file tail $FicTfaChr]
if { ! [regexp {Chr[0-9XY]+$} $Queue Chr]} { set Chr $Queue }
lappend FromChro(ListOf,Chr) $Chr
lappend FromChro(ListOf,Name) $Queue
lappend FromChro(ListOf,File) $FicTfaChr
set Seq [QueLaSequenceDuFichierTFA $FicTfaChr]
set SEQ [string toupper $Seq]
set Length [string length $SEQ]
if { ! [regexp {^(N+)[^N]} $SEQ Match N5] } { set N5 "" }
set L5 [string length $N5]
if { ! [regexp {[^N](N+)$} $SEQ Match N3] } { set N3 "" }
set L3 [string length $N3]
set FromChro($Chr,Length) $Length
set FromChro($Chr,N5) $N5
set FromChro($Chr,L5) $L5
set FromChro($Chr,N3) $N3
set FromChro($Chr,L3) $L3
set DispLength [expr $Length -$L5 -$L3]
set DispStart [expr $DispStop + $Coin]
set DispStop [expr $DispStart + $DispLength]
set FromChro($Chr,DispStart) $DispStart
set FromChro($Chr,DispStop) $DispStop
}
Sauve [array get FromChro] dans $MemoFile
return [FromChro $Qui $Quoi]
}
proc CreateGscopeProjectFromGenbank Strain {
CreateChrGscopeProjectFromGenbank $Strain
CreateCDSGscopeProjectFromGenbank $Strain
Espionne "${Strain}Chr et ${Strain}CDS ont été créés. Pour les voir :"
Espionne "setgscoperr ${Strain}Chr ; gscope"
Espionne "setgscoperr ${Strain}CDS ; gscope"
return "${Strain}CDS"
}
proc CreateChrGscopeProjectFromGenbank Strain {
set LesFicGb [lsort [glob "[pwd]/*.gb"]]
if { ! [OuiOuNon "Je traite [join $LesFicGb \n]"]} { return "" }
set StrainChr "${Strain}Chr"
set RG "/gstock/$StrainChr"
if { ! [file exists $RG]} { file mkdir $RG }
set Link "/genomics/link/$StrainChr"
if { ! [file exist $Link]} { exec ln -sf $RG /genomics/link/$StrainChr }
set Prefixe $StrainChr
NousAllonsAuBoulot $RG
file mkdir beton
file mkdir fiches
file mkdir infos
file mkdir genbankfiles
file mkdir nuctfa
file mkdir nucembl
file mkdir cds
file mkdir rna
set N 0
foreach FicGb $LesFicGb {
set Queue [file tail $FicGb]
if { ! [regexp {(Chr[0-9]+)\.} $Queue Match Chr]} {
Faire Lire "Je ne trouve pas le chr dans $Queue"
continue
}
incr N
set Nom $Strain$Chr
#set FicGb "$RG/DuNcbi/$Nom.gb"
set Gb [ContenuDuFichier $FicGb]
Espionne "$Nom $FicGb"
set FicTfa nuctfa/$Nom
set FicInfos infos/$Nom
if { 1 } {
set Locus "LocusUnknown"
set Definition "DefinitionUnknown"
set OS "OSUnknown"
set OX "OXUnknown"
set OnAttendOrigin 1
set Sequence ""
set OnEstDansCDS 0
set OnEstDansRNA 0
set LesCDSs {}
set LesRNAs {}
set CEstFini 0
set Montre 0
foreach Ligne [split $Gb "\n"] {
if {[regexp "40774553" $Ligne]} { set Montre 0 }
if {[regexp "^//" $Ligne]} { break }
if {$Montre} { Espionne $Ligne ; Espionne onestdansRNA $OnEstDansRNA onestdansCDS $OnEstDansCDS }
regexp {^LOCUS +([^ ]+)( |$)} $Ligne Match Locus
regexp {^DEFINITION +(.+)$} $Ligne Match Definition
regexp {/organism=\"([^\"]+)\"} $Ligne Match OS
regexp {taxon\:([^\"]+)\"} $Ligne Match OX
if {$Montre} { Espionne 1 }
if { ! $OnEstDansCDS && [regexp {^ CDS } $Ligne]} {
set OnEstDansCDS 1
set OnEstDansRNA 0
set LeCDS {}
lappend LeCDS $Ligne
continue
}
if {$Montre} { Espionne 2 }
if { ! $OnEstDansRNA && [regexp {^ (r|t|nc)RNA } $Ligne]} {
set OnEstDansRNA 1
set OnEstDansCDS 0
set LeRNA {}
lappend LeRNA $Ligne
continue
}
if {$Montre} { Espionne 3 $OnEstDansCDS }
if {$OnEstDansCDS} {
if {$OnAttendOrigin && [regexp "^ORIGIN" $Ligne]} { set OnAttendOrigin 0 ; set CEstFini 1 }
if {$CEstFini || [regexp -nocase {^ [a-z]} $Ligne]} {
set CDS [NiceCDSFromCDSLines $LeCDS]
#Espionne $CDS
lappend LesCDSs $CDS
set OnEstDansCDS 0
if { [regexp {^ CDS } $Ligne]} {
set OnEstDansCDS 1
set LeCDS {}
lappend LeCDS $Ligne
continue
}
if { [regexp {^ (r|t|nc)RNA } $Ligne]} {
set OnEstDansRNA 1
set LeRNA {}
lappend LeRNA $Ligne
continue
}
continue
}
lappend LeCDS $Ligne
continue
}
if {$Montre} { Espionne $OnEstDansRNA $OnEstDansRNA }
if {$OnEstDansRNA} {
if {$OnAttendOrigin && [regexp "^ORIGIN" $Ligne]} { set OnAttendOrigin 0 ; set CEstFini 1 }
if {$CEstFini || [regexp -nocase {^ [a-z]} $Ligne]} {
set RNA [NiceRNAFromRNALines $LeRNA]
if {$Montre} { Espionne $RNA }
lappend LesRNAs $RNA
set OnEstDansRNA 0
if { [regexp {^ CDS } $Ligne]} {
set OnEstDansCDS 1
set LeCDS {}
lappend LeCDS $Ligne
continue
}
if { [regexp {^ (r|t|nc)RNA } $Ligne]} {
set OnEstDansRNA 1
set LeRNA {}
lappend LeRNA $Ligne
continue
}
continue
}
lappend LeRNA $Ligne
if {$Montre} { EspionneL $LeRNA }
continue
}
if {$OnAttendOrigin && [regexp "^ORIGIN" $Ligne]} { set OnAttendOrigin 0 ; continue }
if {$OnAttendOrigin} { continue }
set Seq $Ligne
regsub -all -nocase {[^a-z]} $Seq "" Seq
append Sequence $Seq
}
#FaireLire [string length $Sequence]
Sauve $LesCDSs dans cds/$Nom
Sauve $LesRNAs dans rna/$Nom
set Entete ">$Nom $Locus $OS DE=$Definition OX=$OX"
set Tfa [SequenceFormatTFA $Sequence $Entete "nucbrut"]
Sauve $Tfa dans $FicTfa
set LesInfos {}
set OC [TaxClass $OX Name]
regsub {cellular organism; } $OC "" OC
lappend LesInfos "Nom: $Nom"
lappend LesInfos "Locus: $Locus"
lappend LesInfos "Definition: $Definition"
lappend LesInfos "OS: $OS"
lappend LesInfos "OX: $OX"
lappend LesInfos "OC: $OC"
SauveLesLignes $LesInfos dans $FicInfos
#EspionneL $LesInfos
}
}
#EspionneL $LesCDSs
set FicBornes "fiches/bornesdespabs"
CreeBornesDesPABsTroisGradins 1 $N $Prefixe 901 "" "%2.2d" ./
set LeMini {}
lappend LeMini "#MiniConfig"
lappend LeMini "FichierSequenceADN"
lappend LeMini "VersionDeGscopeAuBigBang [VersionDeGscope]"
lappend LeMini "PrefixeDesORFs $Prefixe"
lappend LeMini "LongueurMiniDesORFs 300"
lappend LeMini "NotreOS $OS"
lappend LeMini "NotreOC $OC"
lappend LeMini "NotreOX $OX"
lappend LeMini "GenomeOuCollection Collection"
set Mini [join $LeMini "\n"]
Sauve $Mini dans "beton/miniconfig"
OnRevientDuBoulot
return $Mini
}
proc CleanEcoliCDS {} {
set WrongNuctfa "[RepertoireDuGenome]/WRONG_nuctfa"
set WrongProttfa "[RepertoireDuGenome]/WRONG_prottfa"
file mkdir $WrongNuctfa
file mkdir $WrongProttfa
foreach Nom [ListeDesPABs] {
set Ok($Nom) 1
}
foreach F [glob -nocomplain "[RepertoireDuGenome]/nuctfa/EcoliCDS*"] {
set Q [file tail $F]
if {[info exists Ok($Q)]} { continue }
file rename $F $WrongNuctfa/$Q
}
foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfa/EcoliCDS*"] {
set Q [file tail $F]
if {[info exists Ok($Q)]} { continue }
file rename $F $WrongProttfa/$Q
}
exit
}
proc ArtiChro {} {
set ChroDir [RepertoireDuGenome]
regsub {(Chr|CDS)$} $ChroDir "Chr" ChroDir
regsub {(Chr|CDS)$} $ChroDir "CDS" CdsDir
foreach Ligne [LesLignesDuFichier "$CdsDir/fiches/chr-bornesdespabs"] {
lassign $Ligne Nom ChrD ChrF Sens
lassign [split $ChrD "-"] Chr D
lassign [split $ChrF "-"] Chr F
lappend LesD($Chr) $D
lappend LesCdsD($Chr) $D
lappend LesCdsFins($Chr,$D) $F
lappend LesCdsLignesDe($Chr,$D) $Ligne
lappend LesChr $Chr
lappend LesLignesDe($Chr,$D) $Ligne
}
set LesChr [lsort -unique $LesChr]
foreach Ligne [LesLignesDuFichier "$CdsDir/fiches/chr-bornesdesarns"] {
lassign $Ligne Nom ChrD ChrF Sens
lassign [split $ChrD "-"] Chr D
lassign [split $ChrF "-"] Chr F
lappend LesD($Chr) $D
lappend LesArnD($Chr) $D
lappend LesArnFins($Chr,$D) $F
lappend LesLignesDe($Chr,$D) $Ligne
}
foreach Ligne [LesLignesDuFichier "$CdsDir/fiches/chr-bornesdestrnas"] {
lassign $Ligne Nom ChrD ChrF Sens
lassign [split $ChrD "-"] Chr D
lassign [split $ChrF "-"] Chr F
lappend LesD($Chr) $D
lappend LesTrnaD($Chr) $D
lappend LesTrnaFins($Chr,$D) $F
lappend LesLignesDe($Chr,$D) $Ligne
}
foreach Chr $LesChr {
set LesDAAfficher($Chr) {}
set PreviousDCds -1
foreach D [lsort -unique $LesD($Chr)] {
if {[info exists LesCdsFins($Chr,$D)]} {
set FCds $LesCdsFins($Chr,$D)
lappend LesDAAfficher($Chr) $D
set PreviousDCds $D
set PreviousFCds $FCds
}
if {[info exists LesArnFins($Chr,$D)]} {
set FArn $LesArnFins($Chr,$D)
if {$D<$PreviousFCds} {
lappend LesDParalleles($Chr,$PreviousDCds) $D
} else {
lappend LesDAAfficher($Chr) $D
}
}
if {[info exists LesTrnaFins($Chr,$D)]} {
set FTrna $LesTrnaFins($Chr,$D)
if {$D<$PreviousFCds} {
lappend LesDParalleles($Chr,$PreviousDCds) $D
} else {
lappend LesDAAfficher($Chr) $D
}
}
}
}
set PreviousFrameStart 0
set Ecart [expr 6*3]
set PreviousChr ""
foreach Chr $LesChr {
foreach D $LesDAAfficher($Chr) {
set Ligne [lindex $LesLignesDe($Chr,$D) 0]
lassign $Ligne Nom ChrD ChrF Sens
set Seq [QueLaSequenceDuFichierTFA "$CdsDir/nuctfa/$Nom"]
set Long [string length $Seq]
lassign [split $ChrD "-"] Chr D
lassign [split $ChrF "-"] Chr F
set D3 [expr $D%3]
if {$PreviousChr!=$Chr} {
incr PreviousFrameStart [expr $Ecart*6]
set PreviousF -999
}
if {$D-$PreviousF<99} {
set Between 9
} else {
set Between $Ecart
}
set Start [expr $PreviousFrameStart + $Between + $D3]
set End [expr $Start + $Long - 1]
set PreviousFrameStart [expr $PreviousFrameStart + (($Long+5)*3)/3 + 18*$Ecart]
set PreviousF $F
if {[info exists LesCdsFins($Chr,$D)]} { lappend LesBornesCds "$Nom $Start $End $Sens $ChrD $ChrF $Sens" }
if {[info exists LesArnFins($Chr,$D)]} { lappend LesBornesArn "$Nom $Start $End $Sens $ChrD $ChrF $Sens" }
if {[info exists LesTrnaFins($Chr,$D)]} { lappend LesBornesTrna "$Nom $Start $End $Sens $ChrD $ChrF $Sens" }
if {[info exists LesDParalleles($Chr,$D)]} {
foreach D $LesDParalleles($Chr,$D) {
set Ligne [lindex $LesLignesDe($Chr,$D) 0]
lassign $Ligne Nom ChrD ChrF Sens
set Seq [QueLaSequenceDuFichierTFA "$CdsDir/nuctfa/$Nom"]
set Long [string length $Seq]
lassign [split $ChrD "-"] Chr D
lassign [split $ChrF "-"] Chr F
set D3 [expr $D%3]
if {[info exists LesArnFins($Chr,$D)]} { lappend LesBornesArn "$Nom $Start $End $Sens $ChrD $ChrF $Sens" }
if {[info exists LesTrnaFins($Chr,$D)]} { lappend LesBornesTrna "$Nom $Start $End $Sens $ChrD $ChrF $Sens" }
}
}
}
}
set LaSortie {}
lappend LaSortie [SauveLesLignes $LesBornesCds dans "$CdsDir/fiches/bornesdespabs"]
lappend LaSortie [SauveLesLignes $LesBornesArn dans "$CdsDir/fiches/bornesdesarns"]
lappend LaSortie [SauveLesLignes $LesBornesTrna dans "$CdsDir/fiches/bornesdestrnas"]
return $LaSortie
}
proc CreeBornesdesarnsPourMmusCDS {} {
NousAllonsAuBoulot "/gstock/MmusCDS"
set LesBornes {}
foreach F [lsort [glob -nocomplain "infos/*RNA*"]] {
set Nom [file tail $F]
if {[regexp "tRNA" $Nom]} { continue }
set C [ContenuDuFichier $F]
if { ! [regexp {\nChr: (Chr[0-9][0-9])} $C Match Chr]} { continue }
if { ! [regexp {\(([0-9]+)\..*\.([0-9]+)\)} $C Match Debut Fin]} { continue }
set Sens F
if {[regexp "Bornes: complement" $C]} { set Sens R }
set Bornes "$Nom $Chr-$Debut $Chr-$Fin $Sens"
lappend LesBornes $Bornes
}
SauveLesLignes $LesBornes dans "fiches/chr-bornesdesarns"
OnRevientDuBoulot
return
}
proc CreeBornesdestrnasPourMmusCDS {} {
NousAllonsAuBoulot "/gstock/MmusCDS"
set LesBornes {}
set I 0
foreach F [lsort [glob -nocomplain "infos/tRNA*"]] {
set Nom [file tail $F]
if {[incr I]%100==1} { Espionne $Nom }
set C [ContenuDuFichier $F]
if { ! [regexp {\nChr: (Chr[0-9][0-9])} $C Match Chr]} { continue }
if { ! [regexp {\(([0-9]+)\..*\.([0-9]+)\)} $C Match Debut Fin]} { continue }
set Sens F
if {[regexp "Bornes: complement" $C]} { set Sens R }
set Bornes "$Nom $Chr-$Debut $Chr-$Fin $Sens"
lappend LesBornes $Bornes
}
SauveLesLignes $LesBornes dans "fiches/chr-bornesdestrnas"
OnRevientDuBoulot
return
}
proc CreeBornesdespabPourMmusCDS {} {
FaireLire "Merci de vérifier le code source !!!!!!!!!!!!!"
NousAllonsAuBoulot "/gstock/MmusCDS"
set ToutesLesBornes {}
set I 0
foreach F [lsort [glob -nocomplain "infos/MmusCDS*"]] {
set Nom [file tail $F]
if {[incr I]%100==1} { Espionne $Nom }
set C [ContenuDuFichier $F]
if { ! [regexp {\nChr: (Chr[0-9][0-9])} $C Match Chr]} { continue }
if { ! [regexp {\(([0-9]+)\..*\.([0-9]+)\)} $C Match Debut Fin]} { continue }
set Sens F
if {[regexp "Bornes: complement" $C]} { set Sens R }
set Bornes "$Nom $Chr-$Debut $Chr-$Fin $Sens"
set Gene $Nom
if {[regexp {gene: ([^\n]+)\n} $C Match G]} { set Gene [string trim $G] }
set Long [expr $Fin - $Debut + 1]
lappend LesLongsDe($Gene) $Long
set BornesDe($Gene,$Long) $Bornes
lappend LesGenes $Gene
lappend ToutesLesBornes $Bornes
}
set LesBornes {}
foreach Gene $LesGenes {
if {[info exists DejaVu($Gene)]} { continue }
set DejaVu($Gene) 1
set MaxiLong [MaxiDeLaListe $LesLongsDe($Gene)]
set Bornes $BornesDe($Gene,$MaxiLong)
lappend LesBornes $Bornes
}
SauveLesLignes $ToutesLesBornes dans "fiches/toutesbornesdespabs"
SauveLesLignes $LesBornes dans "fiches/chr-bornesdespabs"
OnRevientDuBoulot
return
}
proc CreeBornesdespabPourMmusCDS_Old {} {
FaireLIre "Merci de vérifier le code source !!!!!!!!!!!!!"
NousAllonsAuBoulot "/gstock/MmusCDS"
set LesBornes {}
set I 0
foreach F [lsort [glob -nocomplain "infos/MmusCDS*"]] {
set Nom [file tail $F]
if {[incr I]%100==1} { Espionne $Nom }
set C [ContenuDuFichier $F]
if { ! [regexp {\nChr: (Chr[0-9][0-9])} $C Match Chr]} { continue }
if { ! [regexp {\(([0-9]+)\..*\.([0-9]+)\)} $C Match Debut Fin]} { continue }
set Sens F
if {[regexp "Bornes: complement" $C]} { set Sens R }
set Bornes "$Nom $Chr-$Debut $Chr-$Fin $Sens"
lappend LesBornes $Bornes
}
SauveLesLignes $LesBornes dans "fiches/bornesdespabs"
OnRevientDuBoulot
return
}
proc RajoutChr {} {
FaireLire "Ne pas me relancer"
NousAllonsAuBoulot "/gstock/MmusCDStemporaire"
foreach F [lsort [glob -nocomplain "infos/MmusCDS*"]] {
set Nom [file tail $F]
set C [ContenuDuFichier $F]
if { ! [regexp {\nChr: (Chr[0-9][0-9])} $C Match Chr]} { continue }
set Texte [ContenuDuFichier "nuctfa/$Nom"]
regsub "\n" $Texte " $Chr\n" X
Sauve $X dans "nuctfa/$Nom"
set Texte [ContenuDuFichier "prottfa/$Nom"]
regsub "\n" $Texte " $Chr\n" X
Sauve $X dans "prottfa/$Nom"
}
OnRevientDuBoulot
return
}
proc CorrigeLesNumeros {} {
FaireLire "Ne plus relancer"
NousAllonsAuBoulot "/genomics/link/MmusCDS"
foreach Dir [list infos nucembl nuctfa protembl prottfa] {
NousAllonsAuBoulot $Dir
Espionne $Dir
foreach F [lsort [glob -nocomplain MMusCDS*]] {
if { ! [regexp {MMusCDS[0-9]+$} $F]} { continue }
regsub MMusCDS $F MmusCDS N
set C [ContenuDuFichier $F]
regsub -all $F $C $N X
Sauve $X dans $N
file delete $F
}
OnRevientDuBoulot
}
OnRevientDuBoulot
return
}
proc CreateChromosomeGenbanksFromGenbank {Fichier} {
set LesLignes [LesLignesDuFichier $Fichier]
set Previous [lindex $LesLignes 0]
set Chr ""
foreach Ligne [lrange $LesLignes 1 end] {
if {[regexp "^DEFINITION " $Ligne]} {
set Chr ""
if { ! [regexp {chromosome ([XY0-9]+)[\, ]} $Ligne Match ChrLu]} { continue }
if {[info exists DejaVu($ChrLu)]} { continue }
set Chr $ChrLu
set LeGbDu($Chr) {}
lappend LeGbDu($Chr) $Previous
lappend LesChr $Chr
Espionne $Chr
set DejaVu($Chr) 1
}
set Previous $Ligne
if {$Chr!="" && ! [regexp "^LOCUS " $Ligne]} { lappend LeGbDu($Chr) $Ligne }
}
set I 0
foreach Chr $LesChr {
incr I
set LeGb $LeGbDu($Chr)
if {$Chr=="X"} { set Chr $I }
if {$Chr=="Y"} { set Chr $I }
set BeauChr [format "Chr%2.2d" $Chr ]
lappend LesFichiers [SauveLesLignes $LeGb dans "$BeauChr.gb"]
}
return $LesFichiers
}
proc CreateCDSGscopeProjectFromGenbank {Strain {UseLocusTag ""}} {
set UseLocusTag [string equal -nocase $UseLocusTag "UseLocusTag"]
set StrainCDS "${Strain}CDS"
set Prefixe $StrainCDS
set FormatOrfNumbering "%5.5d"
set RG /gstock/${Strain}CDS
file mkdir $RG
set Link "/genomics/link/$StrainCDS"
if { ! [file exist $Link]} { exec ln -sf $RG /genomics/link/$StrainCDS }
NousAllonsAuBoulot $RG
file mkdir beton
file mkdir fiches
file mkdir infos
file mkdir nuctfa
file mkdir nucembl
file mkdir prottfa
file mkdir protembl
set RepCDS "/genomics/link/${Strain}Chr/cds"
set RepRNA "/genomics/link/${Strain}Chr/rna"
set N 0
#set N 41181
#zz set SeqTotale "n"
#zz append SeqTotale [string repeat "n" 99]
#zz set Offset [string length $SeqTotale]
set LesBornesDesPABs {}
foreach FichierCDS [lsort [glob -nocomplain "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZz$RepCDS/${Strain}Chr*"]] {
set LesChrBornes {}
set Chr "Chr00"
if { ! [regexp {Chr[0-9]+$} $FichierCDS Chr]} { FaireLire "no Chr in $FichierCDS" }
set ChrDir [file dirname [file dirname $FichierCDS]]
set ChrNuc [QueLaSequenceDuFichierTFA "$ChrDir/nuctfa/${Strain}$Chr"]
set ChrLen [string length $ChrNuc]
set LesCDSs [ContenuDuFichier $FichierCDS]
set OnEstDansSeq 0
foreach CDS $LesCDSs {
set Bornes ""
set ItsOk 1
foreach Ligne [split $CDS "\n"] {
if { ! [regexp {^/([^=]+)=(.*)$} $Ligne Match K V]} { Warne "Wrong $Ligne" ; set ItsOk 0; break }
regsub -all {\"} $V "" V
if {$K=="location"} {
regsub -all {[<>]} $V "" V
set Bornes $V
}
lappend Infos($Chr,$Bornes,ListOfK) $K
set Infos($Chr,$Bornes,$K) $V
}
if {$ItsOk} { lappend LesChrBornes "$Chr $Bornes" }
}
#zz set Offset [string length $SeqTotale]
#zz Espionne "$Chr $ChrLen [llength $LesCDSs] CDS Offset $Offset"
Espionne $Chr $ChrLen [llength $LesCDSs] CDS
foreach ChrBornes $LesChrBornes {
lassign [split $ChrBornes " "] Chr Bornes
if { ! [regexp {([0-9]+)\.\.([0-9]+)} $Bornes Match Deb Fin ]} { Warne "Wrong location $Bornes in $ChrBornes"; continue }
incr N
set Nom [format "%s$FormatOrfNumbering" $Prefixe $N]
if {$UseLocusTag} {
#Espionne [array get Infos "Chr01,190..255,locus_tag"]
#Espionne "$Chr,$Bornes"
if { ! [info exists Infos($Chr,$Bornes,locus_tag)]} {
set Nom [format "%s9999$FormatOrfNumbering" $Prefixe $N]
FaireLire "No locus_tag for $Chr $Bornes"
} else {
set LT $Infos($Chr,$Bornes,locus_tag)
if { ! [regexp {[^0-9]([0-9]+)$} $LT Match LTN]} {
Espionne $LT
FaireLire "No correct locus_tag in $LT"
set Nom [format "%s9999$FormatOrfNumbering" $Prefixe $N]
} else {
Espionne $LT
regsub {^0+} $LTN "" LTN
set Nom [format "%s$FormatOrfNumbering" $Prefixe $LTN]
}
}
}
set Sens "F"
if {[regexp "complement" $Bornes]} { set Sens "R" }
regsub -all {[^0-9\,\.]} $Bornes "" Bo
set LesDF {}
foreach DF [split $Bo ","] {
set D ""
set F ""
if {[regexp {^([0-9]+)\.\.([0-9]+)$} $DF Match D F]} {}
if {[regexp {^([0-9]+)$} $DF D] } {set F $D}
if {$D=="" || $F==""} { Espionne "$Bo" ; exit }
lappend LesDF $D $F
}
set NucCds ""
if {0 && $Chr=="Chr10"} { Espionne "$ChrBornes $LesBo" }
foreach {D F} $LesDF {
if {0 && $Chr=="Chr10"} { Espionne "=$D=$F=" }
if {[catch {append NucCds [string range "n$ChrNuc" $D $F]} Message]} {
Espionne $Message
Espionne "=$ChrBornes=$D=$F="
exit
}
}
if {$Sens=="R"} { set NucCds [NucToReverseAndComplementNuc $NucCds] }
set Deb [lindex $LesDF 0]
set Fin [lindex $LesDF end]
#zz incr Deb $Offset ; incr Deb -1
#zz incr Fin $Offset ; incr Fin -1
lappend LesBornesDesPABs "$Nom $Chr-$Deb $Chr-$Fin $Sens"
set LaFicheInfo {}
lappend LaFicheInfo "Nom: $Nom"
lappend LaFicheInfo "Chr: $Chr"
lappend LaFicheInfo "Bornes: $Bornes"
set Gn ""
set ProCds ""
foreach K $Infos($Chr,$Bornes,ListOfK) {
set V $Infos($Chr,$Bornes,$K)
if {$K=="translation"} {
set ProCds $V
continue
}
if {$K=="gene"} { set Gn $V }
if {$K=="product" && $Gn==""} { set Gn $V }
lappend LaFicheInfo "$K: $V"
}
if {$Gn!=""} { lappend LaFicheInfo "ValiGN: $Gn" }
SauveLesLignes $LaFicheInfo dans "infos/$Nom"
set Entete ">$Nom $Gn $Bornes $Chr"
set NucTfa [SequenceFormatTFA $NucCds $Entete "nucbrut"]
set ProTfa [SequenceFormatTFA $ProCds $Entete "protbrut"]
Sauve $NucTfa dans "nuctfa/$Nom"
Sauve $ProTfa dans "prottfa/$Nom"
}
#zz append SeqTotale $ChrNuc
lappend LesSeqTotale $ChrNuc
#zz set LongTotale [string length $SeqTotale]
#zz set ProchainStart [expr (($LongTotale + 999)/3)*3]
#zz set Tampon [string repeat "n" [expr $ProchainStart-$LongTotale]]
#zzappend SeqTotale $Tampon
}
#rR ATTENTION ici on traite les tRNA rRNA et ncRNA
#zz set SeqTotaleRNA "n"
set LesBornesDesTRNAs {}
set LesBornesDesARNs {}
set LesFichierRNA [lsort [glob -nocomplain "$RepRNA/${Strain}Chr*"]]
foreach FichierRNA $LesFichierRNA {
set LesChrBornes {}
set Chr "Chr00"
if { ! [regexp {Chr[0-9]+$} $FichierRNA Chr]} { FaireLire "no Chr in $FichierRNA" }
set ChrDir [file dirname [file dirname $FichierRNA]]
set ChrNuc [QueLaSequenceDuFichierTFA "$ChrDir/nuctfa/${Strain}$Chr"]
set ChrLen [string length $ChrNuc]
set LesRNAs [ContenuDuFichier $FichierRNA]
set OnEstDansSeq 0
Espionne $Chr
foreach RNA $LesRNAs {
set Bornes ""
set ItsOk 1
foreach Ligne [split $RNA "\n"] {
if { ! [regexp {^/([^=]+)=(.*)$} $Ligne Match K V]} { Warne "Wrong $Ligne" ; set ItsOk 0; break }
Espionne "$K///$V"
regsub -all {\"} $V "" V
if {[regexp {^([^_]+)_location$} $K Match T]} {
#set Type [string toupper $T]
set Type $T
set K "location"
}
if {$K=="location"} {
regsub -all {[<>]} $V "" V
set Bornes $V
set Infos($Chr,$Bornes,Type) $Type
}
lappend Infos($Chr,$Bornes,ListOfK) $K
set Infos($Chr,$Bornes,$K) $V
}
if {$ItsOk} { lappend LesChrBornes "$Chr $Bornes" }
}
#zz set Offset [string length $SeqTotaleRNA]
foreach ChrBornes $LesChrBornes {
lassign [split $ChrBornes " "] Chr Bornes
if { ! [regexp {([0-9]+)\.\.([0-9]+)} $Bornes Match Deb Fin ]} { Warne "Wrong Bornes $Bornes in $ChrBornes" ; continue }
set Type $Infos($Chr,$Bornes,Type)
Espionne "$Chr $Bornes $Type"
set Sens "F"
if {[regexp "complement" $Bornes]} { set Sens "R" }
regsub -all {[^0-9\,\.]} $Bornes "" Bo
set LesDF {}
foreach DF [split $Bo ","] {
set D ""
set F ""
if {[regexp {^([0-9]+)\.\.([0-9]+)$} $DF Match D F]} {}
if {[regexp {^([0-9]+)$} $DF D] } {set F $D}
if {$D=="" || $F==""} { Espionne "$Bo" ; exit }
lappend LesDF $D $F
}
set NucRna ""
if {0 && $Chr=="Chr10"} { Espionne "$ChrBornes $LesBo" }
foreach {D F} $LesDF {
if {0 && $Chr=="Chr10"} { Espionne "=$D=$F=" }
if {[catch {append NucRna [string range "n$ChrNuc" $D $F]} Message]} {
Espionne $Message
Espionne "=$ChrBornes=$D=$F="
}
}
if {$Sens=="R"} { set NucRna [NucToReverseAndComplementNuc $NucRna] }
set Deb [lindex $LesDF 0]
set Fin [lindex $LesDF end]
#zz incr Deb $Offset ; incr Deb -1
#zz incr Fin $Offset ; incr Fin -1
set Gn ""
set AA ""
set AntiCodon ""
foreach K $Infos($Chr,$Bornes,ListOfK) {
set V $Infos($Chr,$Bornes,$K)
if {$K=="product"} {
set Gn [join $V "_"]
regsub -all -nocase {[^a-z0-9\-]} $Gn "_" Gn
regsub -all {_+} $Gn "_" Gn
set Gn [string trim $Gn "_"]
}
if {[string equal -nocase $Type "tRNA"]} {
if {$K=="note" && [regexp {corresponds to s288c [^\(]+\(([^\)]+)\)} $V Match AntiCodon]} {
regsub -all "U" $AntiCodon "T" AntiCodon
Espionne $AntiCodon
}
}
lappend LaFicheInfo "$K: $V"
}
if {[string equal -nocase $Type "tRNA"]} {
set AA $Gn
regsub -nocase {tRNA\-} $AA "" AA
set Nom "tRNA$AA$AntiCodon"
regsub -all -nocase {[^a-z0-9\-]} $Nom "_" Nom
if { ! [info exists NiemeDuNom($Nom)]} { set NiemeDuNom($Nom) 0 }
incr NiemeDuNom($Nom)
set Nom $Nom-$NiemeDuNom($Nom)
} else {
set Nom "$Type-$Gn"
regsub -all -nocase {[^a-z0-9\-]} $Nom "_" Nom
}
if {[string equal -nocase $Type "tRNA"]} {
lappend LesBornesDesTRNAs "$Nom $Chr-$Deb $Chr-$Fin $Sens"
Espionne "$Nom $Chr-$Deb $Chr-$Fin $Sens"
} else {
lappend LesBornesDesARNs "$Nom $Chr-$Deb $Chr-$Fin $Sens"
}
set LaFicheInfo {}
lappend LaFicheInfo "Nom: $Nom"
lappend LaFicheInfo "Chr: $Chr"
lappend LaFicheInfo "Bornes: $Bornes"
if {$Gn!=""} { lappend LaFicheInfo "ValiGN: $Gn" }
SauveLesLignes $LaFicheInfo dans "infos/$Nom"
set Entete ">$Nom $Gn $Bornes $Chr"
set NucTfa [SequenceFormatTFA $NucRna $Entete "nucbrut"]
Sauve $NucTfa dans "nuctfa/$Nom"
}
#zz append SeqTotaleRNA $ChrNuc
#zz set LongTotale [string length $SeqTotaleRNA]
#zz set ProchainStart [expr (($LongTotale + 999)/3)*3]
#zz set Tampon [string repeat "n" [expr $ProchainStart-$LongTotale]]
#zz append SeqTotaleRNA $Tampon
}
SauveLesLignes $LesBornesDesTRNAs dans "fiches/bornesdestrnas"
SauveLesLignes $LesBornesDesARNs dans "fiches/bornesdesarns"
exit
#AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
#zz set FichierSequenceADN "beton/${Strain}_All_Chromosomes.tfa"
#zz set TFA [SequenceFormatTFA [string range $SeqTotale 1 end] ">${Strain}_All_Chromosomes with around 99 n between chromosomes"]
#zz Sauve $TFA dans $FichierSequenceADN
set MiniChr [ContenuDuFichier "/genomics/link/${Strain}Chr/beton/miniconfig"]
set OS [StringSuivant "NotreOS " dans $MiniChr]
set OC [StringSuivant "NotreOC " dans $MiniChr]
set OX [StringSuivant "NotreOX " dans $MiniChr]
set LeMini {}
lappend LeMini "#MiniConfig"
#lappend LeMini "FichierSequenceADN $Link$FichierSequenceADN"
lappend LeMini "FichierSequenceADN /genomics/link/${Strain}Chr/nuctfa/"
lappend LeMini "VersionDeGscopeAuBigBang [VersionDeGscope]"
lappend LeMini "PrefixeDesORFs $Prefixe"
lappend LeMini "LongueurMiniDesORFs 0"
lappend LeMini "NotreOS $OS"
lappend LeMini "NotreOC $OC"
lappend LeMini "NotreOX $OX"
lappend LeMini "GenomeOuCollection Genome"
set Mini [join $LeMini "\n"]
Sauve $Mini dans "beton/miniconfig"
SauveLesLignes $LesBornesDesPABs dans "fiches/bornesdespabs"
SauveLesLignes $LesBornesDesTRNAs dans "fiches/bornesdestrnas"
SauveLesLignes $LesBornesDesARNs dans "fiches/bornesdesarns"
#zz Espionne "CreeADNetTDNetRAC"
#zz Espionne [CreeADNetTDNetRAC [string range $SeqTotale 1 end] "" "."]
OnRevientDuBoulot
return "dernier cree : $Nom"
}
proc MultiWordToTitle {Word {Sep "-"}} {
set LeNom {}
foreach X [split $Word $Sep] {
set X [string totitle $X]
lappend LeNom $X
}
set Nom [join $LeNom $Sep]
}
proc AdressesIsabelle {{GetWhat ""}} {
set LesGroupes {}
NousAllonsAuBoulot "/home/ripp/AdressesIsabelle"
foreach Ligne [LesLignesDuFichier "AdressesIsabelle.txt"] {
if {[string trim $Ligne]==""} { continue }
if {[regexp "^Groupe" $Ligne]} {
regsub -all " " $Ligne "" Groupe
lappend LesGroupes $Groupe
continue
}
set LesMots [LesMotsDuTexte $Ligne]
lassign $LesMots N P A S
set Nom [MultiWordToTitle $N]
set Prenom [MultiWordToTitle $P]
set Mail "$A$S"
set MailMembre [format "%-20s %-20s %s" $Nom $Prenom $Mail]
lappend LesMailsDuGroupe($Groupe) $Mail
lappend LesMembresDuGroupe($Groupe) "$Prenom $Nom"
lappend LesMailsMembresDuGroupe($Groupe) $MailMembre
Espionne $MailMembre
}
set LesCrees {}
foreach Groupe $LesGroupes {
set Virgule [join $LesMailsDuGroupe($Groupe) ", "]
lappend LesCrees [Sauve $Virgule dans MailsAvecVirgule-$Groupe.txt]
lappend LesCrees [SauveLesLignes $LesMailsDuGroupe($Groupe) dans Mails-$Groupe.txt]
lappend LesCrees [SauveLesLignes $LesMembresDuGroupe($Groupe) dans Membres-$Groupe.txt]
lappend LesCrees [SauveLesLignes $LesMailsMembresDuGroupe($Groupe) dans MembresMails-$Groupe.txt]
}
OnRevientDuBoulot
return $LesCrees
}
proc hihi {} {
set L {a {1 2} b {3 4}}
foreach {a xy} $L {
lassign $xy x y
puts "$a $x $y"
}
exit
}
proc SeqFromCode {Code {Length ""}} {
set T(0) A
set T(1) C
set T(2) G
set T(3) T
set Seq ""
for {set I 0} {$I<$Length} {incr I} {
set Last [expr $Code%4]
set Code [expr $Code/4]
set B $T($Last)
set Seq $B$Seq
}
return $Seq
}
proc CodeFromSeq Seq {
set T(A) 0
set T(C) 1
set T(G) 2
set T(T) 3
set Code 0
foreach B [split $Seq ""] {
set Code [expr $Code*4 + $T($B)]
}
return $Code
}
proc ChromosomeLocation {QuerySeq Chr} {
global ChromosomeLocation CurrentChr
if {[info exists CurrentChr] && $Chr==$CurrentChr } {
if {[info exists ChromosomeLocation($QuerySeq)]} {
return $ChromosomeLocation($QuerySeq)
} else {
return -1
}
}
if {[info exists ChromosomeLocation]} { unset ChromosomeLocation }
if {[info exists CurrentChr]} { unset CurrentChr }
set FichierMemo "[ChroSeq $Chr GetDir]/ChromosomeLocation_$Chr.txt"
if { ! [file exists $FichierMemo]} { CreateChromosomeLocation $Chr }
array set ChromosomeLocation [LesLignesDuFichier $FichierMemo]
set CurrentChr $Chr
if {[info exists ChromosomeLocation($QuerySeq)]} { return $ChromosomeLocation($QuerySeq) }
return -1
}
proc CreateChromosomeLocation {Chr {WindowWidth ""} {LastStart ""}} {
if {$WindowWidth==""} { set WindowWidth 12 }
#set Sequence [string range [ChroSeq $Chr] 20000000 20000200]
set Sequence [string range [ChroSeq $Chr] 0 end]
set ChrLen [string length $Sequence]
if {$LastStart==""} { set LastStart [expr $ChrLen-$WindowWidth] }
Espionne "je traite une séquence de longueur $ChrLen"
set Stop [expr $WindowWidth-1-1]
for {set Start 0} {$Start < $LastStart} {incr Start} {
incr Stop
if {$Start%1000000==0} { Espionne $Start }
set Motif [string range $Sequence $Start $Stop]
if {[regexp {[^ACGT]} $Motif]} { continue }
#set CodeMotif [CodeFromSeq $Motif]
lappend PositionOf($Motif) $Start
#lappend PositionOf($CodeMotif) $Start
lappend LesMotifs $Motif
#lappend LesCodeMotifs $CodeMotif
}
set FichierMemo [SauveLesLignes [array get PositionOf] dans "[ChroSeq $Chr GetDir]/ChromosomeLocation_$Chr.txt"]
Espionne [llength [array names PositionOf]] "motifs différents trouvés"
Espionne [llength $LesMotifs] "motifs traités"
return $FichierMemo
}
proc ChroSeq {Chr {GetDir ""}} {
set Chr [string tolower $Chr]
regsub chr0 $Chr chr Chr
regsub chrx $Chr chrX Chr
regsub chry $Chr chrY Chr
set ChroDir "/genomics/link/UCSCGenomes/Homo_sapiens/bigZips200903"
if {$GetDir=="GetDir"} { return $ChroDir }
set FichierFasta "/genomics/link/UCSCGenomes/Homo_sapiens/bigZips200903/$Chr.fa"
if { ! [file exists $FichierFasta]} { return "" }
set Sequence ""
foreach Ligne [LesLignesDuFichier $FichierFasta] {
if {[regexp {^>} $Ligne]} { continue }
set Ligne [string toupper $Ligne]
append Sequence $Ligne
}
return $Sequence
}
proc TestTri {Lequel} {
set L [list 2 8 4 5 4 2 9 1]
return [Tri$Lequel $L]
}
proc TriPosePetit L {
#rR On prend une carte dans la main gauche et une dans la main droite
#rR on pose la plus petite et on ramasse la prochaine carte
#rR Si toute les cartes pôsées sont plus grandes ou égales à la dernière posée on rend la liste
#rR sinon on fait un appel récursif
JeMeSignale
if {[llength $L]<=1} { return $L }
set T {}
set G [lindex $L 0]
set D [lindex $L 1]
set Long [llength $L]
if {$Long==2} {
if {$G<=$D} {
return [list $G $D]
} else {
return [list $D $G]
}
}
set DernierPose "X"
set I 1
set Trie 1
while 1 {
Espionne "$I DernierPose=$DernierPose G=$G D=$D T=$T"
if {$G<=$D} {
if {$DernierPose!="X" && $G<$DernierPose} { set Trie 0 }
set DernierPose $G
lappend T $G
incr I
if {$I<$Long} {
set G [lindex $L $I]
} else {
lappend T $D
break
}
} else {
if {$DernierPose!="X" && $D<$DernierPose} { set Trie 0 }
set DernierPose $D
lappend T $D
incr I
if {$I<$Long} {
set D [lindex $L $I]
} else {
lappend T $G
break
}
}
}
if {$Trie} { return $T }
return [TriPosePetit $T]
}
proc TriBulle L {
#rR On prend la première carte P
#rR Tant que la carte E de la liste est plus grande ou égale à P on pose P et P devient la carte E
#rR Si la carte prise P est plus grande que la carte E
#rR on pose E puis P puis le reste de la liste
#rR et on fait un appel récursif avec la nouvelle liste ainsi créée
JeMeSignale
if {[llength $L]<=1} { return $L }
set T {}
set P [lindex $L 0]
set I 0
foreach E [lrange $L 1 end] {
incr I
if {$P<=$E} {
#On est toujours trié
lappend T $P
set P $E
} else {
#On n'est pas trié
lappend T $E $P
LConcat T [lrange $L $I+1 end]
set Trie 0
return [TriBulle $T]
}
}
return [lappend T $P]
}
proc TriDico L {
#rR On prend la première de la liste. C'est le pivot P
#rR Pour toutes les autres cartes E de la liste on crée
#rR une liste des plus petites L1
#rR une liste des égales LesPivots
#rR une liste des plus grandes L2
#rR On TriDico récursivement L1 et L2
#rR Et on rend les listes L1 LesPivotrs L2 mises bout à bout
JeMeSignale
set N [llength $L]
if {$N<=1} { return $L }
set P [lindex $L 0]
FaireLire "Je partage par le pivot de valeur $P"
set L1 {}
set L2 {}
foreach E $L {
Espionne "$P $E"
if {$E==$P} {
lappend LesPivots $E
} elseif {$E<$P} {
lappend L1 $E
} else {
lappend L2 $E
}
}
set L1 [TriDico $L1]
set L2 [TriDico $L2]
return [concat $L1 $LesPivots $L2]
}
proc TriDiviseEtInterclasse L {
#rR On fait deux listes L1 et L2
#rR en triant récursivement la première et la deuxième moitié de L
#rR Puis on interclasse ces deux listes
#rR en prenant à chaque fois la plus petite carte de L1 et L2
JeMeSignale
FaireLire oui
set N [llength $L]
if {$N<=1} { return $L }
set M [expr $N/2]
Espionne "$N $M"
set L1 [TriDiviseEtInterclasse [lrange $L 0 $M-1]]
set L2 [TriDiviseEtInterclasse [lrange $L $M end]]
set N1 [llength $L1]
set N2 [llength $L2]
set I1 0
set I2 0
set T {}
if {$N1==0} { return $L2 }
if {$N2==0} { return $L1 }
while {$I1<$N1 || $I2<$N2} {
Espionne $I1 $N1 $I2 $N2
#FaireLire oooooooo
if {$I1<$N1 && $I2<$N2} {
set E1 [lindex $L1 $I1]
set E2 [lindex $L2 $I2]
if {$E1<$E2} {
lappend T $E1
incr I1
} else {
lappend T $E2
incr I2
}
continue
}
if {$I1<$N1} {
lappend T $E1
incr I1
} else {
lappend T $E2
incr I2
}
}
return $T
}
proc TriCotte {K LesI LesJ HV} {
JeMeSignale
global R T NbComparaisons NbTours
set KA 0
foreach A $LesI {
incr KA
FaireLire $KA
foreach B [lrange $LesI $KA end] {
set KJA 0
set KJB 0
set LJ [llength $LesJ]
set LeDouble {}
while {1} {
if {$KJA>=$LJ} {
while {$KJB<$LJ} {
set JB [lindex $LesJ $KJB]
set XB [$K gettags $R($HV,$B,$JB)]
set CB [$K itemcget $R($HV,$B,$JB) -fill]
set TB [$K itemcget $T($HV,$B,$JB) -text]
lappend LeDouble [list $HV,$B,$JB $CB $TB $XB]
incr KJB
}
break
}
if {$KJB>=$LJ} {
while {$KJA<$LJ} {
set JA [lindex $LesJ $KJA]
set XA [$K gettags $R($HV,$A,$JA)]
set CA [$K itemcget $R($HV,$A,$JA) -fill]
set TA [$K itemcget $T($HV,$A,$JA) -text]
lappend LeDouble [list $HV,$A,$JA $CA $TA $XA]
incr KJA
}
break
}
set JA [lindex $LesJ $KJA]
set JB [lindex $LesJ $KJB]
set XA [$K gettags $R($HV,$A,$JA)]
set XB [$K gettags $R($HV,$B,$JB)]
set VA [lindex $XA 0]
set VB [lindex $XB 0]
if {$VA<=$VB} {
set CA [$K itemcget $R($HV,$A,$JA) -fill]
set TA [$K itemcget $T($HV,$A,$JA) -text]
lappend LeDouble [list $HV,$A,$JA $CA $TA $XA]
incr KJA
} else {
set CB [$K itemcget $R($HV,$B,$JB) -fill]
set TB [$K itemcget $T($HV,$B,$JB) -text]
lappend LeDouble [list $HV,$B,$JB $CB $TB $XB]
incr KJB
}
}
set k 0
set DD [expr [llength $LeDouble]/2]
set CestTrie 1
foreach E $LeDouble {
if {$k<$DD} {
set I $A
set J [lindex $LesJ [expr $k]]
} else {
set I $B
set J [lindex $LesJ [expr $k-$DD]]
}
incr k
lassign $E Key Col Tex Tags
set KeyDest "$HV,$I,$J"
if {$KeyDest!=$Key} { set CestTrie 0 }
$K itemconfigure $R($KeyDest) -fill $Col
$K itemconfigure $T($KeyDest) -text $Tex
$K itemconfigure $R($KeyDest) -tags $Tags
}
if {$CestTrie} { break }
}
}
return coucou
}
proc TriStep {K LesI LesJ HV} {
global R T NbComparaisons NbTours
foreach I $LesI {
set CestTrie 1
while {1} {
incr NbTours
set CestTrie 1
foreach {A B} $LesJ {
set XA [$K gettags $R($HV,$I,$A)]
set XB [$K gettags $R($HV,$I,$B)]
set VA [lindex $XA 0]
set VB [lindex $XB 0]
incr NbComparaisons
if {$VA<=$VB} { continue }
set CA [$K itemcget $R($HV,$I,$A) -fill]
set TA [$K itemcget $T($HV,$I,$A) -text]
$K itemconfigure $R($HV,$I,$A) -fill [$K itemcget $R($HV,$I,$B) -fill]
$K itemconfigure $T($HV,$I,$A) -text [$K itemcget $T($HV,$I,$B) -text]
$K itemconfigure $R($HV,$I,$B) -fill $CA
$K itemconfigure $T($HV,$I,$B) -text $TA
$K itemconfigure $R($HV,$I,$A) -tags $XB
$K itemconfigure $R($HV,$I,$B) -tags $XA
set CestTrie 0
}
incr NbTours
foreach {A B} [lrange $LesJ 1 end-1] {
set XA [$K gettags $R($HV,$I,$A)]
set XB [$K gettags $R($HV,$I,$B)]
set VA [lindex $XA 0]
set VB [lindex $XB 0]
incr NbComparaisons
if {$VA<=$VB} { continue }
set CA [$K itemcget $R($HV,$I,$A) -fill]
set TA [$K itemcget $T($HV,$I,$A) -text]
$K itemconfigure $R($HV,$I,$A) -fill [$K itemcget $R($HV,$I,$B) -fill]
$K itemconfigure $T($HV,$I,$A) -text [$K itemcget $T($HV,$I,$B) -text]
$K itemconfigure $R($HV,$I,$B) -fill $CA
$K itemconfigure $T($HV,$I,$B) -text $TA
$K itemconfigure $R($HV,$I,$A) -tags $XB
$K itemconfigure $R($HV,$I,$B) -tags $XA
set CestTrie 0
}
if {$CestTrie} { break }
}
}
}
proc TriDiag {K LesI LesJ HV} {
global R T NbComparaisons NbTours
foreach IA [lrange $LesI 0 end-1] IB [lrange $LesI 1 end] {
set CestTrie 1
FaireLire $IA
foreach D [NombresEntre 1 [expr [llength $LesI]-1]] {
FaireLire "decalage $D pour $IA $IB"
foreach A [lrange $LesJ $D end] B [lrange $LesJ 0 end-$D] {
set XA [$K gettags $R($HV,$IA,$A)]
set XB [$K gettags $R($HV,$IB,$B)]
set VA [lindex $XA 0]
set VB [lindex $XB 0]
incr NbComparaisons
if {$VA<=$VB} { continue }
set CA [$K itemcget $R($HV,$IA,$A) -fill]
set TA [$K itemcget $T($HV,$IA,$A) -text]
$K itemconfigure $R($HV,$IA,$A) -fill blue ; #[$K itemcget $R($HV,$IB,$B) -fill]
$K itemconfigure $T($HV,$IA,$A) -text [$K itemcget $T($HV,$IB,$B) -text]
$K itemconfigure $R($HV,$IB,$B) -fill green ; #$CA
$K itemconfigure $T($HV,$IB,$B) -text $TA
$K itemconfigure $R($HV,$IA,$A) -tags $XB
$K itemconfigure $R($HV,$IA,$B) -tags $XA
set CestTrie 0
}
if {0 && $CestTrie} { break }
}
}
}
proc TriCollectif {{NbCases ""}} {
global R T NbComparaisons NbTours
if {$NbCases==""} { set NbCases 8 }
set PasI 30
set MaxI [expr $PasI*$NbCases-1]
set MaxJ $MaxI
set K [UnCanva [expr $MaxI+1] [expr $MaxJ+1] [expr $MaxI+1] [expr $MaxJ+1]]
set PasJ $PasI
set LesI [NombresEntre 0 $MaxI $PasI]
set LesJ [NombresEntre 0 $MaxJ $PasJ]
Espionne $LesI $LesJ
foreach I $LesI {
set DI [expr $I]
set FI [expr {$I+$PasI-1}]
foreach J $LesJ {
set DJ [expr $J]
set FJ [expr {$J+$PasJ-1}]
set Val [expr round(rand()*99)]
set Couleur [format "#%2.2X0000" [expr round(255*$Val/100)]]
set TDI [expr {$DI+$PasI/2}]
set TFI [expr {$FI+$PasI/2}]
set TDJ [expr {$DJ+$PasJ/2}]
set TFJ [expr {$FJ+$PasJ/2}]
set R(H,$I,$J) [$K create rectangle $DI $DJ $FI $FJ -fill $Couleur -outline grey -tags [list $Val]]
set T(H,$I,$J) [$K create text $TDI $TDJ -text $Val -fill white]
}
}
foreach Key [array names R] {
lassign [split $Key ","] h I J
set R(V,$J,$I) $R(H,$I,$J)
set T(V,$J,$I) $T(H,$I,$J)
}
FaireLire "maitenant on trie les colonnes"
TriStep $K $LesI $LesJ H
FaireLire "maitenant on trie les lignes"
TriStep $K $LesI $LesJ V
#FaireLire "maitenant on trie en diagonale"
TriDiag $K $LesI $LesJ V
FaireLire "maitenant on tricotte"
TriCotte $K $LesI $LesJ V
Espionne $NbComparaisons $NbTours
return $K
}
proc Tete aL {
#rR rend le premier élément d'une liste
#rR et enlève cet élément de la liste qui est donc modifiée !!!
upvar $aL L
if {$L=={}} { return "ThastsAllFolks" }
set Tete [lindex $L 0]
set L [lrange $L 1 end]
return $Tete
}
proc TriTete L {
while {[set H [Tete L]] ne "ThastsAllFolks"} {
Espionne $H = $L
}
exit
}
proc MenageDansGenomicsLink {} {
set LesEffaces {}
foreach f [glob -nocomplain -type d /genomics/link/*] {
if {[file type $f]=="link"} { continue }
set Reps [glob -nocomplain $f/*]
set N [llength $Reps]
if {$N>1} { FaireLire "Oups pour $f" }
set Reps [glob -nocomplain $f/fiches/*]
set M [llength $Reps]
Espionne [file type $f] $N $M $f
if {$N==1 && $M==1} { lappend LesEffaces $f ; exec rm -R $f }
}
return $LesEffaces
}
proc CGDelarue {} {
foreach X [list U C A G] {
foreach Y [list U C A G] {
set LaLigne {}
foreach Z [list U C A G] {
set Codon $X$Z$Y
regsub -all U $Codon T CodonT
set A [AAduCodon $CodonT]
lappend LaLigne "$X$Z$Y $A"
}
Espionne [join $LaLigne " "]
}
}
Espionne
foreach X [list A G C U] {
foreach Y [list U C A G] {
set LaLigne {}
foreach Z [list C U G A] {
set Codon $X$Z$Y
regsub -all U $Codon T CodonT
set A [AAduCodon $CodonT]
lappend LaLigne "$X$Z$Y $A"
}
Espionne [join $LaLigne " "]
}
}
}
proc StatsDelarue {} {
set I 0
foreach {Codon A Couleur} [LesMotsDuTexte [ContenuDuFichier "[GscopeDir]/delarue.txt"]] {
incr I
regsub -all U $Codon T CodonT
if {$Couleur=="r"} { incr NbR }
if {$Couleur=="v"} { incr NbV }
if {$Couleur=="m"} { incr NbM }
if {[IsX0 $CodonT]} {
set X "X"
if {$Couleur=="r"} { incr NbXR }
if {$Couleur=="v"} { incr NbXV }
if {$Couleur=="m"} { incr NbXM }
} else {
set X " "
}
if {$I==64} {
Espionne $NbXR/$NbR rouges $NbXV/$NbV verts $NbXM/$NbM mixtes
lassign [list 0 0 0 0 0 0] NbR NbV NbM NbXR NbXV NbXM
}
}
Espionne $NbXR/$NbR rouges $NbXV/$NbV verts $NbXM/$NbM mixtes
}
proc Trrr {} {
Espionne [exec tcsh -c "setrrtools; which renommeRR"]
}
proc g {} {
set LesNoms "
ACensy00001
ACensy00061
ACensy00079
ACensy00198
ACensy00206
ACensy00216
ACensy00230
ACensy00292
ACensy00408
ACensy00421
ACensy00509
ACensy00612
ACensy00621
ACensy00713
ACensy00968
ACensy00978
ACensy01091
ACensy01103
ACensy01154
ACensy01176
ACensy01444
ACensy01499
ACensy01524
ACensy01547
ACensy01566
ACensy01620
ACensy01684
ACensy01790
ACensy01864
ACensy01890
ACensy01899
"
set LesNoms [LesMotsDuTexte $LesNoms]
foreach Nom $LesNoms {
set MesGOs [MyGOsFromGene $Nom]
Espionne "$Nom $MesGOs"
}
return ""
}
proc DeMG {Nom Quoi} {
#set R [QuestionDeScience MG "ret GscopeFileContent $Nom $Quoi"]
set R [QuestionDeScience MG "ret ExtraitInfo $Nom ValiGN"]
set R [QuestionDeScience MG "ret ExtraitInfo $Nom ValiDE"]
return $R
}
set FichierEleGen "/home/ripp/gscope/AtelierGscope/EleGen_proc.tcl"
if {[file exists $FichierEleGen]} { source $FichierEleGen }
proc ComptageMotifsExons {FichierACompter} {
set Fichier $FichierACompter
set NbGenes [exec cut -d , -f 4 $FichierACompter | sort -u | wc -l]
set NbExons [exec cut -d , -f 13 $FichierACompter | sort -u | wc -l]
set NbMotifs [exec cut -d , -f 16 $FichierACompter | sort -u | wc -l]
return "$NbGenes $NbExons $NbMotifs $FichierACompter"
}
proc CreateMotifMappingLevure {FichierMotifAMapper} {
set FichierMotif $FichierMotifAMapper
regsub ".txt" $FichierMotif "_MappingLevure.txt" FichierMotif
set FichierCodonStartExonMix "/home/nguefack/random/levure/levure_R64/S_cerevisiae_StartCodonMix_Position.txt"
set LeNew {}
set LeNew2 {}
set I 0
set DernierTrouve $I
set LesExons [LesLignesDuFichier $FichierCodonStartExonMix]
set N [llength $LesExons]
foreach Ligne [LesLignesDuFichier $FichierMotifAMapper] {
lassign [LesMotsDeLaLigne $Ligne] Chr D F L C U
set I $Deniertrouve
while 1 {
if {$I>=$N} { break }
set Ligne [lindex $LesExons $I]
incr I
set LesMots [LesMotsDeLaLigne $Ligne]
lassign $LesMots ChrA S E GnID GS GE TrID TS TE ExNb ES EE
if {$Chr==$ChrA && $ES <= $D && $D <= $EE} {
set NewLigne "$Chr $S $E $GnID $GS $GE [expr $GE-$GS+1] $TrID $TS $TE [expr $TE-$TS+1] $ExNb $ES $EE [expr $EE-$ES+1] $D $F $L $C $U [expr $D-$E+1]"
lappend LeNew $NewLigne
set DernierTrouve [expr $I-1]
break
}
}
}
SauveLesLignes $LeNew dans $FichierMotif
return "ok"
}
proc OOOOOOOOOOCreateMotifMappingLevure {FichierMotifAMapper} {
set FichierMotif $FichierMotifAMapper
regsub ".txt" $FichierMotif "_MappingLevure.txt" FichierMotif
set FichierCodonStartExonMix "/home/nguefack/random/levure/levure_R64/S_cerevisiae_StartCodonMix_Position.txt"
set LeNew {}
set LeNew2 {}
set LesExons [LesLignesDuFichier $FichierCodonStartExonMix]
set I 0
foreach Ligne [LesLignesDuFichier $FichierMotifAMapper] {
lassign [LesMotsDeLaLigne $Ligne] Chr D F L C U
foreach Ligne $LesExons {
set LesMots [LesMotsDeLaLigne $Ligne]
lassign $LesMots ChrA S E GnID GS GE TrID TS TE ExNb ES EE
if {$Chr!=$ChrA} {continue}
if {$Chr==$ChrA && $ES <= $D && $D <= $EE} {
set NewLigne "$Chr $S $E $GnID $GS $GE [expr $GE-$GS+1] $TrID $TS $TE [expr $TE-$TS+1] $ExNb $ES $EE [expr $EE-$ES+1] $D $F $L $C $U [expr $D-$E+1]"
lappend LeNew $NewLigne
}
}
}
SauveLesLignes $LeNew dans $FichierMotif
return "ok"
}
proc LesTaxIdDeOdile {} {
foreach Ligne [LesLignesDuFichier "[BlastomicsDir]/TTLL.csv"] {
if { ! [regexp {[0-9]+} $Ligne OX]} { continue }
if {[OiCode $OX OI]==""} { lappend LesPerdus "perdu $OX [Tax $OX Name]" }
Espionne "$OX [Tax $OX Name]"
}
return $LesPerdus
}
proc ParcoursFractal {Ax Ay Bx By N} {
if {$N==1} { return "$Ax $Ax $Bx $By" }
set Mx [expr ($Ax+$Bx)/2]
set My [expr ($Ay+$By)/2]
set Ex [expr ($Bx-$Ax)/5]
set Ey [expr ($By-$Ay)/5]
set Ix [expr $Mx-$Ey]
set Iy [expr $My+$Ex]
incr N -1
set D [ParcoursFractal $Ax $Ay $Ix $Iy $N]
set F [ParcoursFractal $Ix $Iy $Bx $By $N]
return [concat $D [lrange $F 2 end]]
}
proc ParcoursFractalGraphe {Ax Ay Bx By N} {
foreach {X Y} [ParcoursFractal $Ax $Ay $Bx $By $N] {
lappend LesX $X
lappend LesY $Y
}
return [Graphe $LesX $LesY]
}
proc LesOXDuFasta FastaFile {
foreach Ligne [LesLignesDuFichier $FastaFile] {
if {[string index $Ligne 0] ne ">"} { continue }
if { ! [regexp {OX=([0-9]+)( |$)} $Ligne Match OX]} { continue }
lappend LesOX $OX
}
set LesOX [lsort -unique $LesOX]
return $LesOX
}
proc CreateBlastDatabaseVertebrataOI2017 {} {
set TaxIdVertebrata [Tax "Vertebrata"]
set FichierBlastDatabase "/blast/OrthoInspector/OiVertebrata"
foreach Fichier [glob -nocomplain "/genomics/link/OrthoInspector_Proteomes/Eukaryota/NotaBene/E*"] {
if { ! [regexp {_([0-9]+)$} $Fichier Match OX]} { continue }
if { ! [JeSuisTonAncetre $TaxIdVertebrata $OX]} { continue }
AppendAuFichier $FichierBlastDatabase [ContenuDuFichier $Fichier]
}
exec formatdb -i $FichierBlastDatabase -p T -l $FichierBlastDatabase.formatdb.log -o
return $FichierBlastDatabase
}
proc CreateBlastDatabaseVertebrata2015 {} {
set RepBanques "[GscopeDatabaseDir CilioCarta]/banques"
set TaxIdVertebrata [Tax "Vertebrata"]
set FichierPal "$RepBanques/Vertebrata2015.pal"
lappend LePal "::::::::::::::"
lappend LePal "Vertebrata2015.pal"
lappend LePal "::::::::::::::"
lappend LePal "#"
lappend LePal "# Alias file created by Gscope CreateBlastDatabaseVertebrata2015"
lappend LePal "#"
lappend LePal "#"
lappend LePal "TITLE Vertebrata2015"
lappend LePal "#"
foreach Fichier [glob -nocomplain "$RepBanques/*"] {
if { ! [regexp {_([0-9]+)$} $Fichier Match OX]} { continue }
if { ! [JeSuisTonAncetre $TaxIdVertebrata $OX]} { continue }
lappend LesQueue [file tail $Fichier]
}
set Dblist "DBLIST [join $LesQueue { }]"
lappend LePal $Dblist
lappend LePal "#"
SauveLesLignes $LePal dans $FichierPal
return $FichierPal
}
proc TestCheminRR {} {
global T LNOrdali
set LNOrdali [list s01 s02 s03 s04 s05 s06 s07 s08]
array set T [ContenuDuFichier "/home/moumou/Agents/filsde.dat"]
# foreach {K V} [array get T] {
# lassign [split $k ,] n1 ag1
# Espionne "$K"
# }
set n1 s01
foreach k [array names T "$n1,*"] {
lassign [split $k ,] n1 ag1
set A "$n1,$ag1"
set B "$n1,$ag1"
set Lchemin [CheminsAgentRR $A $B]
puts "\n$A :"
puts [join $Lchemin \n]
}
exit
}
proc FilsDeRR {P} {
global T LNOrdali DeuxTours
if { ! [info exists T]} {
set LNOrdali [list s01 s02 s03 s04 s05 s06 s07 s08]
array set T [ContenuDuFichier "/home/moumou/Agents/filsde.dat"]
}
lassign [split $P ,] n1 ag1
set i [lsearch -exact $LNOrdali $n1]
if {$i == ([llength $LNOrdali] - 1)} {
set i -1
set DeuxTours 1
}
set nf [lindex $LNOrdali $i+1]
set Lf [lsearch -inline -all -exact -index 0 [lrange $T($n1,$ag1) 0 end] $nf]
set res [list]
foreach f $Lf {
lassign $f nf agf scf
if {[llength $T($nf,$agf)] > 0} {
lappend res "$nf,$agf"
}
}
return $res
}
proc FilsDeRROLD P {
set FilsDe(A) { B C D E}
set FilsDe(B) { C E}
set FilsDe(C) {A E}
set FilsDe(D) { C E}
set FilsDe(E) {A D }
if {[info exists FilsDe($P)]} { return $FilsDe($P) }
return ""
}
proc CheminsAgentAARR {a b} {
global LesBonsSousChemins MaxNiveau
set R [CheminsAgentRR $a $b]
Espionne $MaxNiveau
return $R
}
proc CheminsAgentRR {a b} {
# JeMeSignale
global LesBonsSousChemins NiveauAgent AreteDejaVu MaxNiveau
set LesCheminsDesFils {}
if {[regexp "s08" $a]} { return "Arrive"; set LesCheminsDesFils [list "Arrive"] }
if { ! [info exists NiveauAgent]} { set NiveauAgent 0 ; set MaxNiveau 0 }
incr NiveauAgent
set MaxNiveau [Maxi $MaxNiveau $NiveauAgent]
set Decal [string repeat "\t" $NiveauAgent]
foreach fils [FilsDeRR $a] {
if {$fils==$a} { continue }
if {[info exists AreteDejaVu($a-$fils)]} { continue }
set AreteDejaVu($a-$fils) 1
# Espionne ""
# Espionne "$Decal filsde $a = $fils"
set LesCheminsDuFils [CheminsAgentRR $fils $b]
#set LesBonsSousChemins($a-$fils) $LesCheminsDuFils
foreach CheminTrouve $LesCheminsDuFils {
set CheminParcouru "$a-$fils $CheminTrouve"
# Espionne "$Decal trouve $CheminParcouru"
lappend LesCheminsDesFils $CheminParcouru
}
unset AreteDejaVu($a-$fils)
# Espionne "$Decal LesCheminsDuFils $LesCheminsDuFils"
}
# Espionne "LesCheminsDesFils $LesCheminsDesFils"
incr NiveauAgent -1
return $LesCheminsDesFils
}
proc Fourmis {{X ""} {Y ""} {S ""} {H ""} {L ""} {W ""}} {
LesDefauts
source /home/ripp/gscope/gscope_fourmis.tcl
global TFB
if {$X!=""} { set TFB(dimX) $X }
if {$Y!=""} { set TFB(dimY) $Y }
if {$S!=""} { set TFB(step) $S }
if {$H!=""} { set TFB(headFourmi) $H }
if {$L!=""} { set TFB(lenFourmi) $L }
if {$W!=""} { set TFB(widFourmi) $W }
return [DrawFourmis]
}
proc AutoPathes {} {
set RivetBob [list /usr/lib/tcltk/rivet2.1 /usr/lib/tcltk/rivet2.1/rivet-tcl /usr/lib/tcltk/rivet2.1/packages /usr/lib/tcltk/rivet2.1/packages-local /usr/lib/tcltk/rivet2.1 /usr/share/tcltk/tcl8.5 /usr/share/tcltk /usr/lib /usr/local/lib/tcltk /usr/local/share/tcltk /usr/lib/tcltk/x86_64-linux-gnu /usr/lib/tcltk /usr/share/tcltk/tcllib1.15 . /usr
/local/ActiveTcl/lib /usr/local/ActiveTcl/lib/tcllib1.14 /usr/local/ActiveTcl/lib/tcl3d0.4.1 /usr/local/ActiveTcl/lib/tklib0.4 /usr/local/ActiveTcl/lib/tclx8.4]
set RivetEna [list /usr/lib/tcltk/rivet2.1 /usr/lib/tcltk/rivet2.1/rivet-tcl /usr/lib/tcltk/rivet2.1/packages /usr/lib/tcltk/rivet2.1/packages-local /usr/lib/tcltk/rivet2.1 /usr/share/tcltk/tcl8.5 /usr/share/tcltk /usr/lib /usr/local/lib/tcltk /usr/local/share/tcltk /usr/lib/tcltk/x86_64-linux-gnu /usr/lib/tcltk /usr/share/tcltk/tcllib1.15 . /usr/local/ActiveTcl/lib /usr/lib/tclx8.4 /usr/local/ActiveTcl/lib/tcl3d0.4.1 /usr/local/ActiveTcl/lib/tcllib1.14 /usr/local/ActiveTcl/lib/tklib0.4]
EspionneL [ListsComplement $RivetEna $RivetBob]
exit
}
proc Py {} {
foreach Double [Pythonerie ListOf Double] {
}
}
proc Pythonerie {{Qui ""} {Quoi ""}} {
global Pythonerie
if {[info exists Pythonerie($Qui,$Quoi)]} { return $Pythonerie($Qui,$Quoi) }
if {[info exists Pythonerie("EstCharge")]} { return "" }
set Pythonerie("EstCharge") 1
set RePy "/home/ripp/blam/cgi-bin"
NousAllonsAuBoulot $RePy
foreach FiPy [lsort [glob -nocomplain *.py]] {
regsub {.py$} $FiPy "" Fi
lappend Pythonerie(ListOf,FiPy) $FiPy
lappend Pythonerie(ListOf,Fi) $Fi
foreach Ligne [LesLignesDuFichier $FiPy] {
if {[regexp {import ([a-zA-Z]+)} $Ligne Match Imported]} {
lappend Pythonerie($Fi,imports) $Imported
lappend Pythonerie($Imported,importedfrom) $Fi
}
if {[regexp {from ([a-zA-Z]+) } $Ligne Match Imported]} {
lappend Pythonerie($Fi,imports) $Imported
lappend Pythonerie($Imported,importedfrom) $Fi
}
if {[regexp {^def ([a-zA-Z]+) *\(} $Ligne Match Def]} {
lappend Pythonerie(ListOf,Def) $Def
lappend Pythonerie($Def,Fi) $Fi
lappend Pythonerie($Def,args) $Ligne
}
}
}
set Pythonerie(ListOf,Def) [lsort -unique $Pythonerie(ListOf,Def)]
foreach Def $Pythonerie(ListOf,Def) {
# Espionne "$Def [llength $Pythonerie($Def,Fi)]"
if {[llength $Pythonerie($Def,Fi)]>1} {
lappend Pythonerie(ListOf,Double) $Def
Espionne "$Def : $Pythonerie($Def,Fi)"
}
}
OnRevientDuBoulot
Espionne ""
return [Pythonerie $Qui $Quoi]
}
proc ChangePrintToToBrowserInPythonFile {FicIn FicOut} {
set LeNew {}
foreach Ligne [LesLignesDuFichier $FicIn] {
set New $Ligne
if {[regexp {^( *# *[^p])print +(.*)$} $Ligne Match Deb Fin]} {
set New "${Deb}toBrowser($Fin)"
}
if {[regexp {^([^p]+)print +(.*)$} $Ligne Match Deb Fin]} {
set New "${Deb}toBrowser($Fin)"
}
lappend LeNew $New
}
SauveLesLignes $LeNew dans $FicOut
exec meld $FicIn $FicOut
exit
}
proc TestOr {} {
LesDefauts
Espionne $::Defauts(PrefixesBank)
exit
}
proc LesVieuxLiens {} {
foreach RF [glob "/genomics/*/*/banques"] {
foreach Lien [glob -nocomplain "$RF/*"] {
if {[file type $Lien]!="link"} { continue }
set Cible [file readlink $Lien]
set QueueCible [file tail $Cible]
set RepCible [file dirname $Cible]
if {[file tail $RepCible]=="banques"} {
set Autre [file tail [file dirname $RepCible]]
set BonAutre "[GscopeDatabaseDir $Autre]/banques/$QueueCible"
Espionne "\n"
Espionne $Lien
exec rm $Lien
exec ln -s $BonAutre $Lien
}
}
}
}
proc RemplacePartout {Ancien Nouveau {Login ""} {OverWrite ""}} {
#rR si Login finit par .tcl c'est un fichier
if {[string equal -nocase $Login "OverWrite"]} { set Login ""; set OverWrite "OverWrite" }
set OverWrite [string equal -nocase $OverWrite "OverWrite"]
if { ! $OverWrite } {
FaireLire "Now you'll change nothing. \n To OverWrite use RemplacePartout Ancien Nouveau Login OverWrite"
} else {
if { ! [OuiOuNon "I'll overwrite what I'm allowed to do. OK?"] } { exit }
}
set PourUnFichierPrecis 0
set LesSources [LesSourcesDeGscope]
if {[regexp "\.tcl$" $Login]} {
set LesSources [list $Login]
set Login ""
set PourUnFichierPrecis 1
}
set LesMAJ {}
foreach F $LesSources {
if {[regexp -nocase "Poubelle/" $F]} { continue }
if { ! [regexp ".tcl$" $F]} { continue }
if {$Login!="ripp" && $Login!="" && ! [regexp "/$Login/" $F]} { continue }
if {$Login=="ripp" && [regexp "/" $F]} { continue }
if { ! $PourUnFichierPrecis } { set F "[HomeRipp]/gscope/$F" }
set LeNew {}
set OK 1
foreach Ligne [LesLignesDuFichier $F] {
if { ! [regexp $Ancien $Ligne]} { lappend LeNew $Ligne; continue }
set OK 0
regsub -all $Ancien $Ligne $Nouveau New
lappend LeNew $New
Espionne $Ligne
Espionne $New
lappend LesLignesG $Ligne $New
}
if {$OK} { continue }
Espionne $F
Espionne
if { ! [file writable $F]} {
FaireLire "Je ne peux pas modifier $F"
continue
}
if {$OverWrite} { lappend LesMAJ [SauveLesLignes $LeNew dans $F] }
}
AfficheListe $LesMAJ
}
proc InsereGenomicsLink {{Login ""} {OverWrite ""}} {
#rR si Login finit par .tcl c'est un fichier
if {[string equal -nocase $Login "OverWrite"]} { set Login ""; set OverWrite "OverWrite" }
set OverWrite [string equal -nocase $OverWrite "OverWrite"]
if { ! $OverWrite } {
FaireLire "Now you'll change nothing. \n To OverWrite use InsereGenomicsLink Login OverWrite"
} else {
if { ! [OuiOuNon "I'll overwrite what I'm allowed to do. OK?"] } { exit }
}
set PourUnFichierPrecis 0
set LesSources [LesSourcesDeGscope]
if {[regexp "\.tcl$" $Login]} {
set LesSources [list $Login]
set Login ""
set PourUnFichierPrecis 1
}
set LesMAJ {}
foreach F $LesSources {
if { ! [regexp ".tcl$" $F]} { continue }
if {$Login!="" && ! [regexp "/$Login/" $F]} { continue }
if { ! $PourUnFichierPrecis } { set F "[HomeRipp]/gscope/$F" }
set LeNew {}
set OK 1
foreach Ligne [LesLignesDuFichier $F] {
if { ! [regexp {/genomics/g[0-9]+/} $Ligne]} { lappend LeNew $Ligne; continue }
set OK 0
regsub -all {/genomics/g[0-9]+/} $Ligne "/genomics/link/" New
lappend LeNew $New
Espionne $Ligne
Espionne $New
lappend LesLignesG $Ligne $New
}
if {$OK} { continue }
Espionne $F
if { ! [file writable $F]} {
FaireLire "Je ne peux pas modifier $F"
continue
}
if {$OverWrite} { lappend LesMAJ [SauveLesLignes $LeNew dans $F] }
}
AfficheListe $LesMAJ
set LesMAJ2 {}
foreach F $LesSources {
if { ! [regexp ".tcl$" $F]} { continue }
if {$Login!="" && ! [regexp "/$Login/" $F]} { continue }
if { ! $PourUnFichierPrecis } { set F "[HomeRipp]/gscope/$F" }
set LeNew {}
set OK 1
foreach Ligne [LesLignesDuFichier $F] {
if { ! [regexp {/genomics/} $Ligne]} { lappend LeNew $Ligne; continue }
if { [regexp {/genomics/link/} $Ligne]} { lappend LeNew $Ligne; continue }
if { [regexp {/genomics/g[^/]+/} $Ligne]} { lappend LeNew $Ligne; continue }
set OK 0
regsub -all {/genomics/} $Ligne "/genomics/link/" New
lappend LeNew $New
Espionne $Ligne
Espionne $New
lappend LesLignesG $Ligne $New
}
if {$OK} { continue }
Espionne $F
if { ! [file writable $F]} {
FaireLire "Je ne peux pas modifier $F"
continue
}
if {$OverWrite} { lappend LesMAJ2 [SauveLesLignes $LeNew dans $F] }
}
AfficheListe $LesMAJ2
}
proc ProcDuFichier {P Fichier} {
if {[FileAbsent $Fichier]} {
set Fichier "[GscopeDir]/$Fichier"
if {[FileAbsent $Fichier]} {
set Fichier "[GscopeContrib]/$Fichier"
if {[FileAbsent $Fichier]} { return "" }
}
}
set DansProc 0
set LaProc {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! $DansProc} {
if { ! [regexp "^proc $P " $Ligne] } { continue }
}
if { $DansProc && [regexp "^proc " $Ligne] } { break }
set DansProc 1
lappend LaProc $Ligne
}
set Proc [join $LaProc "\n"]
set iAF [string last "\}" $Proc]
set Proc [string range $Proc 0 $iAF]
return [string trim $Proc " \n"]
}
proc ProcDeGscopeEnDouble {} {
set Xoue [exec xoue "proc "]
foreach Ligne [split $Xoue "\n"] {
if { ! [regexp {^([g/][^\:]+)\:proc ([^ ]+) } $Ligne Match Ou P]} { continue }
if {[regexp obsolete $Ligne]} { continue }
if {[regexp sm2ph $Ligne]} { continue }
if {[regexp "OLD.tcl" $Ou]} { continue }
if {[regexp "Old.tcl" $Ou]} { continue }
if {[regexp "luc.tcl" $Ou]} { continue }
lappend OuE($P) $Ou
lappend LesP $P
}
set LesP [lsort -unique $LesP]
foreach P $LesP {
if {[llength $OuE($P)]>1} {
set QueJmuller 1
foreach O $OuE($P) {
if { ! [regexp "jmuller" $O]} { set QueJmuller 0 }
}
if {$QueJmuller} { continue }
set QueChalmel 1
foreach O $OuE($P) {
if { ! [regexp "chalmel" $O]} { set QueChalmel 0 }
}
if {$QueChalmel} { continue }
set PT $P
set Prems 1
foreach Ou $OuE($P) {
set IlsSontIdentiques "============================================"
set Ref [ProcDuFichier $P [lindex $Ou 0]]
foreach O [lrange $OuE($P) 1 end] {
if {$Ref!=[ProcDuFichier $P $O]} {
set IlsSontIdentiques ""
break
}
}
if {[string trim $PT]!=""} {
lappend LesDoubles ""
lappend LesDoubles "$PT $IlsSontIdentiques"
set PT [string repeat " " [string length $PT]]
}
lappend LesDoubles "$PT $Ou"
if {$Prems} {
set Prems 0
set PT [string repeat " " [string length $PT]]
}
}
}
}
set Clavier "Postpone"
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "Magenta"
TouchePour $Clavier "Compare les procs" "CompareLesProcs \[selection get\]"
TouchePour <2> "/meld" "CompareLesProcs \[selection get\] Meld"
set Fenetre [AfficheListe $LesDoubles]
return $Fenetre
}
proc CompareLesProcs {Selection {Meld ""}} {
regsub -all {[ \t\n]+} $Selection " " Selection
regsub -all gscope_contrib $Selection [GscopeContrib]
regsub -all " gscope/" $Selection " [HomeRipp]/gscope" Selection
lassign [split [string trim $Selection " \n"] " "] P F1 F2
Espionne $P
Espionne $F1
Espionne $F2
scan $P "%s" P
set B1 [ProcDuFichier $P $F1]
set B2 [ProcDuFichier $P $F2]
if {$Meld!=""} {
regsub -all "/" $F1 "_" NF1
regsub -all "/" $F2 "_" NF2
Sauve $B1 dans [set TB1 [TmpFile $NF1]]
Sauve $B2 dans [set TB2 [TmpFile $NF2]]
exec meld $TB1 $TB2 &
} else {
set A1 [Affiche $B1 "" "${P}_de_$F1"]
set A2 [Affiche $B2 "" "${P}_de_$F2"]
return [list $A1 $A2]
}
return ""
}
proc DeFromUniprotData {{FicAc ""} {FicDe ""}} {
foreach Ac [LesLignesDuFichier $FicAc] {
set DE [QuestionDeScience GeneQuid "ret UniprotData $Ac DE-"]
lappend LesDe $DE
}
return [SauveLesLignes $LesDe dans $FicDe]
}
proc GnFromUniprotData {{FicAc ""} {FicGn ""}} {
foreach Ac [LesLignesDuFichier $FicAc] {
set GN [QuestionDeScience GeneQuid "ret UniprotData $Ac GN"]
if {$GN==""} { continue }
set Name [StringApres "Name=" dans $GN]
regsub ";" $Name "" Gn
lappend LesGn $Gn
}
return [SauveLesLignes $LesGn dans $FicGn]
}
proc HomeLinksPlanbis {} {
file mkdir "/planbis/maison/homeLinks"
NousAllonsAuBoulot "/maison/homeLinks"
set LesLiens [glob -nocomplain *]
set LesNews {}
foreach Lien $LesLiens {
if {[file type $Lien]!="link"} { continue }
set Target [file readlink $Lien]
Espionne "$Lien pointe sur $Target"
regsub "^/maison" $Target "/planbis/maison" New
set Queue [file tail $New]
set NewLink "/planbis/maison/homeLinks/$Queue"
exec ln -s $New "/planbis/maison/homeLinks/$Queue"
lappend LesNews $NewLink
}
return $LesNews
}
proc AddPV {} {
foreach Ligne [LesLignesDuFichier /planbis/commun/dbsql/backups/PRIVILEGES_201602071520.sql] {
append Ligne ";"
lappend LeNew $Ligne
}
SauveLesLignes $LeNew dans /planbis/commun/dbsql/backups/MYSQL_PRIVILEGES_201602071520.sql
}
proc VerifFungi {} {
set NbFungi 0
foreach Ligne [LesLignesDuFichier "/genomics/link/BaDe/banques/Proteome201501_TaillesDesOs.txt"] {
set LesMots [split $Ligne "_"]
set TaxId [lindex $LesMots 2]
set EstDansProteome($TaxId) 1
if {[QuestionDeScience EVImm "ret JeSuisTonAncetre Fungi $TaxId"]} { incr NbFungi }
}
set NbHitFungi 0
foreach Ligne [LesLignesDuFichier "/genomics/link/BaDe/taxobla/BaDe00007"] {
set LesMots [LesMotsDuTexte $Ligne]
set TaxId [lindex $LesMots 2]
set OS [lindex $LesMots 3]
if {[QuestionDeScience EVImm "ret JeSuisTonAncetre Fungi $TaxId"]} {
incr NbHitFungi
}
}
Espionne "$NbFungi $NbHitFungi"
}
proc TestWali {{Quoi ""}} {
#rR Attention ici on redéfinit certaines choses .. donc à ne pas exécuter dans Wali
global WaliSourceDir ; set WaliSourceDir "[HomeRipp]/wwwLinux/wali" ; source $WaliSourceDir/wali_source.tcl
if {[info proc SESSION]==""} { proc SESSION args { return "" } }
if {$Quoi=="TaxonomyToHTML"} { return [TaxonomyToHTML CIL007] }
return [UlAli "[WaliRootDir]/example.rsf"]
}
proc lmPDBSearch {} {
package require http
::http::config -urlencoding utf-8
#<?xml version=\"1.0\" encoding=\"UTF-8\"?>
set xml "\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<orgPdbCompositeQuery version=\"1.0\">
<queryRefinement>
<queryRefinementLevel>0</queryRefinementLevel>
<orgPdbQuery>
<version>head</version>
<queryType>org.pdb.query.simple.EnzymeClassificationQuery</queryType>
<description>Enzyme Classification Search : EC=6.1.1.*</description>
<Enzyme_Classification>6.1.1.*</Enzyme_Classification>
</orgPdbQuery>
</queryRefinement>
<queryRefinement>
<queryRefinementLevel>1</queryRefinementLevel>
<conjunctionType>and</conjunctionType>
<orgPdbQuery>
<version>head</version>
<queryType>org.pdb.query.simple.ExpTypeQuery</queryType>
<description>Experimental Method is X-RAY</description>
<mvStructure.expMethod.value>X-RAY</mvStructure.expMethod.value>
</orgPdbQuery>
</queryRefinement>
</orgPdbCompositeQuery>\""
set xml "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<orgPdbQuery>
<version>B0907</version>
<queryType>org.pdb.query.simple.ExpTypeQuery</queryType>
<description>Experimental Method Search : Experimental Method=SOLID-STATE NMR</description>
<mvStructure.expMethod.value>SOLID-STATE NMR</mvStructure.expMethod.value>
</orgPdbQuery>"
set url "http://www.rcsb.org/pdb/rest/search/"
# set url "http://lbgi.fr"
set query [::http::formatQuery data "$xml"]
puts "[string range $query 0 end]"
#set query [string range $query 6 end]
# set rep [HttpCopy $url -query $query]
set rep [::http::geturl $url -query $query]
exit
puts "$rep"
puts "[info body ::http::geturl]"
#set rep [::http::data [::http::geturl $url]]
#exit
#set rep [::http::data [::http::geturl $url -query $query]]
exit
}
proc RenommeInterRatio {} {
#InterRatioGeneList_0430_20_7_MExRetAdult_MExBrnAdult_16629.worst
foreach F [lsort [glob "[HomeRipp]/GxWww/HtmlTableStore/InterRatio*"]] {
set Q [file tail $F]
set LesMots [split $Q "_"]
lassign $LesMots Racine Date Exp Soft
lassign [split [lindex $LesMots end] "."] Size Type
set Samples [join [split [lrange $LesMots 4 end-1]] "_"]
regsub "worst" $Type "wors" Type
# Espionne
# Espionne $Q
# EspionneL "$Racine $Date $Exp $Soft $Samples $Size $Type"
set New [join [list $Racine $Date $Size $Type $Exp $Soft $Samples] "_"]
Espionne $New
set NewFile "[file dirname $F]/$New"
file rename $F $NewFile
}
exit
}
proc TestDict2Json {} {
set D [Json]
source "[HomeRipp]/Desktop/exp_json.tcl"
return [::json::dict2json $D]
}
proc PrettyDict {D {Comment ""}} {
global PrettyDict
if { ! [string is list $D] || ([llength $D] & 1) || ([llength $D]==0)} {
Espionne [llength $D]
if {[llength $D]==15} { Espionne $D; exit }
return $D
}
append PrettyDict(tab) " "
set Tab $PrettyDict(tab)
foreach K [dict keys $D *] {
set V [dict get $D $K]
if { ! [string is list $V]} {
set Pretty $V
} else {
set Pretty [PrettyDict $V]
}
append Retour "\n$Tab$K :"
append Retour "$Tab $Pretty"
}
return $Retour
}
proc Json {} {
source "[HomeRipp]/Desktop/exp_json.tcl"
Espionne [info procs ::json::*]
# set TJ [ContenuDuFichier "[HomeRipp]/json.txt"]
set TJ [ContenuDuFichier "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=24026985&retmode=json"]
set TJ [encoding convertfrom "utf-8" $TJ]
set D [::json::json2dict $TJ]
return $D
Espionne $TJ
set D [json::json2prettydict $TJ]
Espionne $D
return $D
exit
set Pretty [PrettyDict $D]
Espionne $Pretty
exit
set d [string first "Stoetzel" $TJ]
set f [expr $d +220]
Espionne [string range $TJ $d $f]
exit
# regsub -all {u'([^']*)'} $TJ {"\1"} TJ
# Espionne [string range $TJ 0 end]
set D [::json::json2dict $TJ]
return $D
Espionne $D
exit
dict for {k v} D {
Espionne "k=$k"
Espionne "v=$v"
}
# Espionne $D
exit
}
proc MenageGenomicsManu {} {
cd /genomics/link
set LesLiens [glob -nocomplain "*Manu*"]
foreach Lien $LesLiens {
if {[file type $Lien]!="link"} { continue }
set Target [file readlink $Lien]
# Espionne "$Lien pointe sur $Target"
set G [glob -nocomplain $Target]
if {$G=={}} {
Espionne "$Target"
if {[catch {exec ls $Target} Message]} { Espionne $Message }
# file delete $Lien
}
Espionne "$Lien pointe sur $Target"
}
exit
}
proc GeneQuid args {
#rR AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAttention
if {[Hostname]=="bob"} {
return [ContenuDuFichier "http://lbgi.fr/wscoperr?GeneQuid&[join $args &]"]
}
set R [QuestionDeScience "GeneQuid" "ret [join $args { }]"]
#LogWscope $R
return $R
}
proc SeqDuEmbl {} {
set Texte [ContenuDuFichier "/genomics/link/CilioCarta/protembl/HSAP00001"]
regexp {\nSQ[^\n]+\n([^/|$]+)(/|$)} $Texte Match Sequence
regsub -all -nocase {[^a-z]} $Sequence "" Sequence
return $Sequence
}
proc ReadFile Fichier {
set Size [file size $Fichier]
#rR pour un test
Espionne $Size
set f [open $Fichier]
set BufferSize 134217728
fconfigure $f -buffersize $BufferSize
set Con ""
set i 0
while { ! [eof $f]} {
Espionne [incr i]
lappend LesPortions [read $f $BufferSize]
}
set Tout [join $LesPortions ""]
Espionne [string length $Tout]
}
proc FromInterproWeb {} {
package require http
set Url "http://www.biomart.org/biomart/martservice?type=registry"
set LaQuery [list \
ATTRIBUTES \
entry.default.entry_attributes.entry_id|entry.default.entry_attributes.entry_short_name|entry.default.entry_attributes.entry_name|entry.default.entry_attributes.entry_type|entry.default.entry_attributes.pos_from|entry.default.entry_attributes.protein_ac|entry.default.entry_attributes.protein_name|entry.default.entry_attributes.pos_to|entry.default.entry_attributes.match_score|entry.default.entry_attributes.protein_database_name|entry.default.entry_attributes.protein_tax_id \
FILTERS \
"entry.default.filter_page.protein_ac.\"P12345,P12346\"" \
formatter \
TSV \
]
set Query [::http::formatQuery {*}$LaQuery]
# append Url "&ATTRIBUTES=entry.default.entry_attributes.entry_id|entry.default.entry_attributes.entry_short_name|entry.default.entry_attributes.entry_name|entry.default.entry_attributes.entry_type|entry.default.entry_attributes.pos_from|entry.default.entry_attributes.protein_ac|entry.default.entry_attributes.protein_name|entry.default.entry_attributes.pos_to|entry.default.entry_attributes.match_score|entry.default.entry_attributes.protein_database_name|entry.default.entry_attributes.protein_tax_id&FILTERS=entry.default.filter_page.protein_ac.P12345&FORMAT=TSV"
# append Url "&ATTRIBUTES=entry.default.entry_attributes.entry_id&FILTERS=entry.default.filter_page.protein_ac.P12345&FORMAT=TSV"
append Url "&$Query"
set R [ContenuDuFichier $Url]
return $R
}
proc Imap {} {
package require imap4
package require tls
#set user luc.moulinier
set user raymond.ripp
#set pass "#Derry5#"
set pass "bmifb123"
#set server mailserver.u-strasbg.fr
set server 130.79.200.160
set FOLDER "INBOX.Labo"
# Connect to server
set ::imap4::use_ssl 1
set imap [::imap4::open $server 993]
puts "imap $imap"
::imap4::login $imap $user $pass
puts "login done"
set Lfold [::imap4::folders $imap -inline]
puts "[join $Lfold \n]"
::imap4::select $imap $FOLDER
# Output all the information about that mailbox
foreach info [::imap4::mboxinfo $imap] {
puts "$info -> [::imap4::mboxinfo $imap $info]"
}
# fetch 3 records inline
set fields {from: to: subject: size text fintextewwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww}
foreach rec [::imap4::fetch $imap 2:5 -inline {*}$fields] {
puts -nonewline "#[incr idx])"
for {set j 0} {$j<[llength $fields]} {incr j} {
puts "\t[lindex $fields $j] [lindex $rec $j]"
}
}
# Show all the information available about the message ID 1
puts "Available info about message 1: [::imap4::msginfo $imap 1]"
# Use the capability stuff
puts "Capabilities: [::imap4::isableto $imap]"
puts "Is able to imap4rev1? [::imap4::isableto $imap imap4rev1]"
# Cleanup
::imap4::cleanup $imap
return
}
proc BashFromTcsh {{FileT ""} {FileB ""}} {
if {$FileB==""} { set FileB "$FileT.bash" }
if {[file exists $FileT]} {
set T [ContenuDuFichier $FileT]
} else {
set T $FileT
}
set LeOld [split $T "\n"]
set LeNew {}
set PremiereLigne 1
foreach Ligne [split $T "\n"] {
Espionne $Ligne
# if {[regexp "set NoGcg=1" $Ligne]} { exit }
set New $Ligne
if {$PremiereLigne && [regexp {^#!.*/tcsh} $New]} {
set New "#!/bin/bash\n#rR converted from tcsh by BashFromTcsh"
set PremiereLigne 0
lappend LeNew $New
continue
}
if {[regexp {([ \t]*)(set)([ \t]+)([^=]+)(=)([ \t]*)(\$<)} $New Match B1 Set B2 Var B3 Egal B4 Chevron]} {
set New "${B1}read $Var"
}
set YaSet 0
set YaSetenv 0
if {[regexp {(^|[ \t]+)set([ \t]+)([^ \t=]+)} $New]} {
set YaSet 1
regsub {(^|[ \t]+)set([ \t]+)([^ \t=]+)} $New "\\1\\3@=@" New
}
if {[regexp {(^|[ \t]+)setenv([ \t]+)([^ \t]+)} $New]} {
set YaSetenv 1
regsub {(^|[ \t]+)setenv([ \t]+)([^ \t]+)} $New "\\1export \\3@=@" New
}
if {$YaSet || $YaSetenv} {
regsub {([ \t]*)@=@=?([ \t]*)} $New "\\1@=@" New
if {[regexp {@=@([^0-9\"\'].*)$} $New]} {
# regsub {@=@([^0-9].*)$} $New "@=@\"\\1\"" New
}
regsub {@=@} $New "=" New
}
if {[regexp {(^[ \t]*)(alias)([ \t]+)([^ \t]+)([ \t]+)(.*)} $New Match B1 Alias B2 Nom B3 Valeur]} {
if { ! [regexp {[\"\']} $Valeur]} {
regsub -all "\"" $Valeur "\\\"" Valeur
set Valeur "\"$Valeur\""
}
set New "$B1$Alias$B2$Nom=$Valeur"
}
# B1 If B2 Op Exp B3 Clo Suite
if {[regexp {(^[ \t]*)(if)([ \t]+)(\()([^\)]+)([ \t]*)(\))(.*)} $New Match B1 If B2 Open Exp B3 Close Suite]} {
set Exp [string trim $Exp]
# set OBash "\[\["
# set CBash "\]\]"
set OBash "test"
set CBash " "
set EBash $Exp
# set EBash [string map {"==" "-eq" "!=" "-ne" "<" "-lt" ">" "-gt" "<=" "-le" ">=" "-ge"} $Exp]
set EBash [string map {"<" "\\<" ">" "\\>-gt"} $Exp]
regsub -nocase -all {\$\?([a-z0-9_]+)} $EBash "$\{\\1\+x\}" EBash
set Suite [string trim $Suite]
if {$Suite=="then"} {
set Suite "; then"
} else {
set Suite "; then $Suite ; fi"
}
set New "${B1}if $OBash $EBash $CBash $Suite"
Espionne
Espionne $Ligne
Espionne $New
lappend LeNew $New
continue
}
if {[regexp {(^[ \t]*)(endif)(.*)} $New Match B1 EndIf Suite]} {
set New "${B1}fi"
lappend LeNew $New
continue
}
Espionne $Ligne
if {[regexp {(^[ \t]*)(unset(env)?)([ \t]+)(.*)} $New Match B1 Unset Env B2 Suite]} {
set New "${B1}unset$B2$Suite"
lappend LeNew $New
Espionne "B1 =$B1="
Espionne "unset=$Unset="
Espionne "B2 =$B2="
Espionne "Suite=$Suite="
}
lappend LeNew $New
}
SauveLesLignes $LeNew dans $FileB
exec meld $FileT $FileB &
exit
AfficheListe $LeOld "" "TCSH"
AfficheListe $LeNew "AvecRetour" "BASH"
return $LeNew
}
proc ChangeBlastOutputFormat {FicIn {FicOut ""}} {
#rR pour que Ballast puisse lire les sortie Blast 2.9 !!!!!!
#rR attention ce programme est dans gscope et dans un executable indépendant (penser a la mise a jour)
#rR (/biolo/rrballast/ en attendant de trouver mieux)
#rR Je ne fais pas grand' chose si ce n'est d'échanger Query et Database et de changer Length=
#rR avec Arnaud on a aussi modifire ballast en rajoutant des 2* a certains malloc !!!!!!!
if {$FicOut==""} { set FicOut "$FicIn.new" }
set f [open $FicIn "r"]
set Texte [read -nonewline $f]
close $f
regsub {Length=([0-9]+)} $Texte " (\\1 letters)" Texte
regsub -all {\nLength=([0-9]+)} $Texte "\n Length = \\1" Texte
set LeBon {}
set InDatabase 0
set ColleDatabase 0
if {[string first "\nDatabase:" $Texte] < [string first "Query=" $Texte]} {
set WaitForDatabase 1
} else {
set WaitForDatabase 0
}
set WaitForResume 1
set AfterSbjct 0
foreach Ligne [split $Texte "\n"] {
if {$InDatabase} {
append Database "\n$Ligne"
set InDatabase 0
set ColleDatabase 1
continue
}
if {$WaitForDatabase && [regexp "^Database" $Ligne]} {
set WaitForDatabase 0
set Database $Ligne
set InDatabase 1
continue
}
if {$ColleDatabase && [regexp {\([0-9]+ letters\)} $Ligne]} {
lappend LeBon $Ligne
lappend LeBon "\n$Database"
set ColleDatabase 0
continue
}
if {$AfterSbjct} {
if {[regexp -nocase {[a-z]} $Ligne]} {
set AfterSbjct 0
if { ! [regexp {(^ *Score|^Query|^>)} $Ligne]} {
lappend LeBon " Database: see below (this line was added by BlastOutputFormat for compatibility reasons)\n"
}
}
}
lappend LeBon $Ligne
if {[regexp "^Sbjct" $Ligne]} { set AfterSbjct 1 }
}
set Bon [join $LeBon "\n"]
set f [open $FicOut "w"]
puts $f $Bon
close $f
return $FicOut
}
proc AliCartoon {} {
#rR c'est pour faire une petite animation d'un alignement (pour Renaud)
#rR on part de l'alignemnet et on le des-aligne ... ;-)
set K [UnCanva 200 1600 200 200]
lappend Ali "..QLKIPV.YV.SLTNQTAKE"
lappend Ali "TAQVKIQ........NQTAKE"
lappend Ali "...VKIQVHYVDSLTNQ"
set LargAli 0
foreach Seq $Ali {
set LargAli [expr max($LargAli,[string length $Seq])]
}
set I 0
foreach Seq $Ali {
set S($I) "$Seq[string repeat . [expr $LargAli-[string length $Seq]]]"
incr I
}
set LesGaps {}
foreach I [array names S] {
set J 0
foreach AA [split $S($I) ""] {
if { ! [regexp {[^\.]} [string range $S($I) $J end]]} { break }
if {$AA=="."} { lappend LesGaps "$I $J" }
incr J
}
}
set N [llength $LesGaps]
set CSGX 20
set CSGY [expr 20 + $N*50]
set DeplacementY 0
set CSGY [expr 20]
set Tic 0
while {1} {
Cartoon $K S $CSGX $CSGY ; incr CSGY $DeplacementY
FaireLire "Au suivant"
if {$LesGaps=={}} { break }
set L [llength $LesGaps]
set Z [expr round(floor(rand()) * $L)]
lassign [lindex $LesGaps $Z] I J
set S($I) "[string replace $S($I) $J $J]."
set LesGaps {}
foreach I [array names S] {
set J 0
foreach AA [split $S($I) ""] {
if { ! [regexp {[^\.]} [string range $S($I) $J end]]} { break }
if {$AA=="."} { lappend LesGaps "$I $J" }
incr J
}
}
}
}
proc Cartoon {K aS CSGX CSGY} {
global Cartoon
upvar $aS S
set MaxJ [expr [string length $S(0)] - 1]
set MaxI [expr [llength [array names S]] -1]
set W 10
set H 10
if {[info exists Cartoon(CSGX)]} {
if {$Cartoon(CSGX)==$CSGX && $Cartoon(CSGY)==$CSGY} {
foreach R $Cartoon(ListOfR) {
$R delete
}
}
set Cartoon(ListOfR) {}
}
foreach I [NombresEntre 0 $MaxI] {
set DY [expr $CSGY + $H*$I]
set FY [expr $DY + $H]
foreach J [NombresEntre 0 $MaxJ] {
set DX [expr $CSGX + $W*$J]
set FX [expr $DX + $W]
set AA [string index $S($I) $J]
set Couleur [lindex [LesCouleursSeqlabDesAAs $AA] 1]
if {$AA=="."} { set Couleur "white" }
set R [$K create rectangle $DX $DY $FX $FY -fill $Couleur -outline $Couleur]
lappend Cartoon(ListOfR) $R
}
}
}
proc NucProteomeDir {} {
return "/genomics/link/ImAnnoGenes/nucproteome"
}
proc OrfWithStop {} {
foreach Nom [ListeDesPABs] {
set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "prottfa"]]
if { ! [regexp "X" $Seq]} { continue }
lappend LesBad $Nom
}
AfficheListe $LesBad
}
proc CreateImAnnoGenes {{WhatToDo ""}} {
set Rep "/genomics/link/ImAnnoGenes"
file mkdir "$Rep/nuctfa"
file mkdir "$Rep/prottfa"
if {$WhatToDo==""} { set WhatToDo [ChoixParmi [list "DoSeq" "DoBornesDoSeq" "InformeOnly"]] }
set LongSeqDefaut 99
set Bornes {}
set Deb 100
foreach LesValeurs [lrange [GPG Get All] 0 end] {
set Fin [expr $Deb + $LongSeqDefaut - 1]
foreach K [GPG ListOf keys] V $LesValeurs {
set $K $V
}
set Nom $nom
set Gn $name
if {[regexp "DoSeq" $WhatToDo]} {
set FicNuc "[NucProteomeDir]/$Gn.tfa"
if {[FileAbsent $FicNuc] || [file size $FicNuc]==0} {
set TfaNuc ">$Nom $Gn not found yet\nATGTGA"
set TfaPro ">$Nom $Gn not found yet\nATGTGA"
} else {
set TfaNuc [ContenuDuFichier $FicNuc]
regsub ">" $TfaNuc ">$Nom " TfaNuc
set Entete [EnteteDuTexteTFA $TfaNuc]
set SeqNuc [QueLaSequenceDuTexteTFA $TfaNuc]
set SeqPro [SeqNucToSeqPro $SeqNuc]
set TfaPro [SequenceFormatTFA $SeqPro $Entete "protbrut"]
}
Sauve $TfaNuc dans "$Rep/nuctfa/$Nom"
Sauve $TfaPro dans "$Rep/prottfa/$Nom"
}
lappend Bornes "$Nom $Deb $Fin"
set Deb [expr $Deb + $LongSeqDefaut + 1]
if {[regexp "Informe" $WhatToDo]} {
InformeSansDemander $Nom "=NM: $accessnum"
InformeSansDemander $Nom "=ValiGN: $Gn"
InformeSansDemander $Nom "=ValiDE: $description"
InformeSansDemander $Nom "=PkImAnno: $pk"
InformeSansDemander $Nom "=GenePaintId: $gpid"
InformeSansDemander $Nom "=EntrezId: $entrezid"
}
}
if { ! [regexp "Borne" $WhatToDo]} { return "Je n'ai pas recréé bornesdespabs" }
set FicBornes [SauveLesLignes $Bornes dans "$Rep/fiches/bornesdespabs"]
return $FicBornes
}
proc MiseAJourGPG {} {
CanalSqlGenoret
FaireLire "Merci de ne plus m'executer "
exit;
foreach Ligne [LesLignesDuFichier "[HomeRipp]/gpg.txt"] {
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
scan $Ligne "%s %s %s" Gpid NM Gn
set Gn [string trim $Gn ":"]
set Sql "select gpid,name,accessnum from imanno.gpaintgene where gpid='$Gpid';"
lassign [SqlExec $Sql "GetList"] i n a
Espionne $Ligne
if {$a!=""} { FaireLire "$Ligne \n $i $n $a" }
#if {$n!=$Gn} { FaireLire "$Ligne \n $i $n $Gn" }
set Update "update imanno.gpaintgene set accessnum='$NM' where gpid='$Gpid';"
SqlExec $Update
Espionne $Update
}
}
proc MiseAJourGPGOLD {} {
CanalSqlGenoret
# set LesK [split "gpid,name,description,accessnum,entrezid,rnaprobe,orientation,hybridtemp,wahstemp,stage,strain,sectionplane,resol,dissecdate,dissectime" ","]
set LesK [split "gpid,name,description" ","]
foreach K $LesK {
}
set Sql "select pk_gpaintgene,description from imanno.gpaintgene where description like 'ENEPAINT Set%';"
set LesD [SqlExec $Sql "GetList"]
foreach {pk D} $LesD {
regsub -all {[\n\r]+} $D "\n" D
regsub -all {[ \t]+} $D " " D
regsub -all {Accession number:[ \n\r]+} $D "Accession number: " D
regsub -all {Entrez Gene ID:[ \n\r]+} $D "Entrez Gene ID:" D
if {0} {
Espionne
Espionne $pk
Espionne "**********"
Espionne $D
Espionne "**********"
}
foreach K $LesK Ligne [split $D "\n"] {
set V [StringApres ":" dans $Ligne]
if {$K=="description"} { set V [StringSuivant ":" dans $Ligne] }
set V [string trim $V " :;."]
# Espionne "$K $V"
set OldV [SqlExec "select $K from imanno.gpaintgene where pk_gpaintgene=$pk"]
if {$K=="description"} {
# Espionne "DDDDD"
regsub -all "'" $V "''" V
} else {
# Espionne "OldV=$OldV="
}
if {$K=="name" && $OldV!=$V && [OuiOuNon "$OldV!=$V Do I keep $OldV"] } { continue }
set Update "update imanno.gpaintgene set $K='$V' where pk_gpaintgene=$pk;"
Espionne $Update
if {[OuiOuNonMemo "Do I execute all updates" 0]} { SqlExec $Update }
}
}
}
proc PourGPG {{GetWhat ""}} {
# AfficheListe [GPG Get All]; return
set LesNM {}
foreach LesValeurs [lrange [GPG Get All] 0 end] {
foreach K [GPG ListOf keys] V $LesValeurs {
set $K $V
}
set Gn $name
set FicNuc "[NucProteomeDir]/$Gn.tfa"
if {$GetWhat!="GetNM" && [file exists $FicNuc]} { continue }
lappend LesPk $pk
lappend LesGn $name
lappend LesNM $accessnum
}
if {$GetWhat=="GetNM"} { return $LesNM }
set NbOK 0
set NbKO 0
set LesCds [CdsFromNM $LesNM "Mus musculus"]
foreach Pk $LesPk Gn $LesGn NM $LesNM Cds $LesCds {
if {[regexp ">NotFound" $Cds]} {
Espionne ""
Espionne "$Pk $Gn $NM"
Espionne "$Cds"
incr NbKO
} else {
incr NbOK
Sauve $Cds dans "[NucProteomeDir]/$Gn.tfa"
}
}
if {[OuiOuNon "Je lance le projet"]} {
}
return "$NbOK $NbKO"
}
proc GPG {{Qui ""} {Quoi ""}} {
global GPG
if {$Quoi=="pk_gpaintgene"} { set Quoi "pk" }
if {[info exists GPG($Qui,$Quoi)]} { return $GPG($Qui,$Quoi) }
if {[info exists GPG("EstCharge")]} { return "" }
set GPG("EstCharge") 1
CanalSqlGenoret
#rR attention pk_gpaintgene devient pk
set Headers "pk_gpaintgene gpid name description accessnum entrezid rnaprobe orientation hybridtemp washtemp stage strain sectionplane resol dissecdate dissectime textoriginal"
set Sql "select * from imanno.gpaintgene"
set R [SqlExec $Sql "GetList"]
set GPG(ListOf,keys) [list pk gpid name accessnum entrezid rnaprobe description]
set Bidon 12345
set Seed 12345; expr srand($Seed)
set Method "SRAND"
set GPG(ListOf,Random) {}
foreach {pk gpid name description accessnum entrezid rnaprobe orientation hybridtemp washtemp stage strain sectionplane resol dissecdate dissectime textoriginal} $R {
if {$Method=="SRAND"} {
set Random [expr rand()]
while {[info exists DejaVu($Random)]} { set Random [expr rand()] }
} else {
if {$entrezid=="" || $rnaprobe=="" || [regexp {[^0-9]} $entrezid] || [regexp {[^0-9]} $rnaprobe]} {
set Random [expr [incr Bidon]*13+[incr Bidon]*7]
} else {
set Random [expr $entrezid*13+$rnaprobe*7]
}
set Random [string range $Random 1 end-1]
while {[info exists DejaVu($Random)]} {
Espionne "Rand deja vu $Random" ; set Random [expr $Random*17]
}
}
set DejaVu($Random) 1
lappend GPG(ListOf,Random) $Random
if {[info exists DejaVu($name)]} { FaireLire "DejaVu $name" }
foreach K $GPG(ListOf,keys) {
set GPG($pk,$K) [set $K]
set GPG($name,$K) [set $K]
lappend GPG(ListOf,$K) [set $K]
}
set GPG($Random) $pk
}
set GPG(ListOf,Random) [lsort $GPG(ListOf,Random)]
foreach K $GPG(ListOf,keys) {
set GPG(ListOf,$K) [lsort -unique $GPG(ListOf,$K)]
}
lappend GPG(ListOf,keys) nom
set LesRandomises {}
set I 10000
foreach Random $GPG(ListOf,Random) {
set pk $GPG($Random)
incr I 10
set nom [format "IA%5.5d" $I]
set GPG($pk,nom) $nom
set LesValeurs {}
foreach K $GPG(ListOf,keys) {
lappend LesValeurs $GPG($pk,$K)
}
lappend GPG(ListOf,NomName) "$GPG($pk,nom) $GPG($pk,name)"
lappend LesRandomises $LesValeurs
}
set GPG(Get,All) $LesRandomises
CanalSqlDisconnect
return [GPG $Qui $Quoi]
}
proc TestCenar {} {
set G [QueLaSequenceDuFichierTFA "/genomics/link/Cenar/beton/cenarchaeum_symbiosum.tfa"]
regsub -all -nocase {[ATGC]} $G "" g
Espionne $g
set O [QueLaSequenceDuFichierTFA "/home/sage2014/odile/NC_014820.tfa"]
if {$G==$O} { FaireLire "C bon" }
exit
}
proc InformeEFFamily {} {
foreach Nom [ListeDesPABs] {
set LL [LesLignesDuFichier [GscopeFile $Nom "protembl"]]
DecortiqueLesLignesEMBL $LL ID AC DE GN OS
InformeSansDemander $Nom "Alias: $AC"
InformeSansDemander $Nom "Organism: $OS"
}
}
proc EFFamily {} {
set Source "/home/legrand/Documents/EF_family/EF_family_id.txt"
set RepDestin "/genomics/link/EFFamily/DeBaptiste"
file mkdir "$RepDestin/pdb"
file mkdir "$RepDestin/embl"
file mkdir "$RepDestin/tfa"
set i 0
foreach Ligne [LesLignesDuFichier "/home/legrand/Documents/EF_family/EF_family_id.txt"] {
incr i; set Nom [format "EF%3.3d" $i]
if {[regexp {([0-9]+)} [string range $Ligne 4 end] Match Domain ]} {
InformeSansDemander $Nom "HasDomain: $Domain"
}
scan $Ligne "%s" ACCESSPDB
if {$ACCESSPDB=="1QLAA2"} { set ACCESSPDB "2BS2_A" }
set AccessPDB [string tolower $ACCESSPDB]
if {[regexp -nocase {^([0-9][A-Z0-9]{3})([A-Z]?)} $AccessPDB Match Acc Chain]} {
set AccessPDB ${Acc}
if {$Chain!=""} { append AccessPDB "_$Chain" }
}
set Pdb [TextePDB $AccessPDB]
if {$Pdb==""} {
Espionne "$ACCESSPDB $AccessPDB ???????????????????????????????"
continue
}
Espionne "$ACCESSPDB $AccessPDB OK"
set Embl [EMBLduPDB $AccessPDB]
set Tfa [SequenceFormatTFA $Embl "" "embl"]
#Affiche "$Embl\n\n$Tfa" "AvecRetour"
set FichierPdb [Sauve $Pdb dans "$RepDestin/pdb/$AccessPDB"]
set FichierEmbl [Sauve $Embl dans "$RepDestin/embl/EF_$AccessPDB.embl"]
set FichierTfa [Sauve $Tfa dans "$RepDestin/tfa/EF_$AccessPDB.tfa"]
lappend LaListe "$AccessPDB $FichierTfa"
}
return [SauveLesLignes $LaListe dans "$RepDestin/liste.txt"]
}
proc AddUsers {} {
set LesU {}
# lappend LesU [AddUser collet 3356 3000 Pierre Collet /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser schreiner 3357 3000 Clément Schreiner /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser abotsi 3358 3000 Isaac Abotsi /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser julio 3359 3000 Julio Navarra-Lara /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser cardosi 3360 3000 Paul Cardosi /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser raaj 3361 3000 Raaj Seereekisson /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser michel 3362 3000 Christian Michel /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser parrend 3363 3000 Pierre Parrend /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser karim 3364 3000 Karim El-Soufi /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser willaume 3365 3000 Pierre Willaume /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser colin 3366 3000 Florent Colin /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser deruyver 3367 3000 Aline Deruyver /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser guigou 3368 3000 Fabio Guigou /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser masai 3369 3000 Pierre Masai /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser mazzu 3370 3000 Timothée Mazzucotelli /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser toussaint 3371 3000 Nicholas Toussaint /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser pasquier 3372 3000 Jean-Yves Pasquier /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser chene 3373 3000 Jocelyn Chene /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser mesny 3374 3000 Fantin Mesny /maison /usr/bin/tcsh "" CreateDir]
# lappend LesU [AddUser joly 3375 3000 Mickael Joly /maison /usr/bin/tcsh "" CreateDir]
# lappend LesU [AddUser leonteva 3376 3000 Anna Leonteva /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser huber 3377 3000 Laurine Huber /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser jeannin 3378 3000 Anne Jeannin /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser pupka 3379 3000 Cedric Pupka /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser lmary 3380 3000 Lora Mary /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser guth 3381 3000 Catherine Guth /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser haegelin 3382 3000 Marc Haegelin /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser bruyant 3383 3000 Alexandre Bruyant /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser mayer 3386 3000 Claudine Mayer /maison /usr/bin/tcsh "" CreateDir]
# lappend LesU [AddUser durand 3387 3000 Dylan Durand /maison /usr/bin/tcsh "" CreateDir]
# lappend LesU [AddUser michaud 3388 3000 Paul-Armand Michaud /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser jaafra 3389 3000 Yasmina Jaafra /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser lecompte 3390 3000 Odile Lecompte /maison /usr/bin/tcsh "" CreateDir]
# lappend LesU [AddUser lenz 3391 3000 Birger Lenz /maison /usr/bin/tcsh "" CreateDir]
# lappend LesU [AddUser grosjean 3393 3000 Maxime Grosjean /maison /usr/bin/tcsh "" CreateDir]
# lappend LesU [AddUser delhomme 3394 3000 X Delhomme /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser sereni 3395 3000 Jean-Sebastien Sereni /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser gopal 3396 3000 Gopal Dila /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser pirot 3397 3000 François Pirot /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser biancalana 3398 3000 Valérie Biancalana /maison /bin/bash "" CreateDir]
# lappend LesU [AddUser baguette 3939 3017 Audrey Baguette /maison /bin/tcsh "" CreateDir]
set FichierLdap [SauveLesLignes $LesU dans "[HomeRipp]/rh/Ldap_[Date Seconds].txt"]
return $FichierLdap
}
proc AddUser {{Login ""} {Uid ""} {Gid ""} {Prenom ""} {Nom ""} {HomeDir ""} {Shell ""} {Hash ""} {CreateDir ""}} {
if {$Login==""} { set Login [Entre "Login="] }
if {$Uid==""} { set Uid [Entre "Uid="] }
if {$Gid==""} { set Gid [Entre "Gid=3000"] }
if {$Prenom==""} { set Prenom [Entre "Prenom="] }
if {$Nom==""} { set Nom [string toupper [Entre "NOM="]] }
if {$HomeDir==""} { set HomeDir [Entre "Home=/maison"] }
if {$Shell==""} { set Shell [Entre "Shell=/bin/bash"] }
set Secret "[string tolower [string index $Prenom end][string index $Nom end]]2016"
if {$Hash==""} { set Hash [Entre "Password=$Secret"] ; regsub "Password=" $Hash "" Hash ; set Hash [string trim $Hash] }
if {$CreateDir==""} { set CreateDir "CreateDir" }
if { ! [regexp {^\{} $Hash]} { set Hash [exec slappasswd -h "{SSHA}" -s $Hash] }
set CreateDir [string equal -nocase "CreateDir" $CreateDir]
foreach K {Login Uid Gid Prenom Nom HomeDir Shell} {
regsub {[^=]*=} [set $K] "" $K
set $K [string trim [set $K]]
regsub { } [set $K] "-" $K
if {$K=="Nom"} { set $K [string toupper [set $K]] }
Espionne "$K [set $K]"
}
set LesNouveaux [list "$Login $Uid $Gid $Prenom $Nom $HomeDir $Shell"]
set LesInfos {}
set LeLdap {}
foreach Ligne $LesNouveaux {
lassign [split $Ligne " "] Login Uid Gid Prenom Nom HomeDir Shell
Espionne $Ligne
lappend LesInfos $Ligne
if {$CreateDir || [OuiOuNonMemo "Je crée les répertoires ?" 0]} {
file mkdir "$HomeDir/$Login"
if { ! [file exists /home/$Login]} { exec ln -s $HomeDir/$Login /home/ }
}
lappend LeLdap "dn: uid=$Login,ou=users,dc=lbgi,dc=fr"
lappend LeLdap "objectClass: inetOrgPerson"
lappend LeLdap "objectClass: posixAccount"
lappend LeLdap "cn: $Login"
lappend LeLdap "sn: $Nom"
lappend LeLdap "givenName: $Prenom"
lappend LeLdap "homeDirectory: /home/$Login"
lappend LeLdap "loginShell: $Shell"
lappend LeLdap "uidNumber: $Uid"
lappend LeLdap "gidNumber: $Gid"
lappend LeLdap "userPassword: $Hash"
lappend LeLdap ""
incr UID
}
return [join $LeLdap "\n"]
}
proc CreateESBS2016 {} {
set UID 4051
set Hash [exec slappasswd -h "{SSHA}" -s esbs2016]
set LesInfos {}
set LeLdap {}
foreach Ligne [LesLignesDuFichier "[HomeRipp]/Enseignement/ESBS2016/ListeESBS2016.txt"] {
regsub -all {[ \t]+} $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
set L ""
lassign [split $Ligne " "] P N M L ;#rR attention ordre différent
if {$L==""} { set L [string tolower $N] }
set Existant ""
set NonExistant [catch {set Existant [exec getent passwd $L]}]
set N [string toupper $N]
set Info "$L $P $N $UID 3116 esbs16 /home/$L esbs2016"
Espionne $Info
if { ! $NonExistant} {
FaireLire "$L already exists \n $Existant"
continue
}
lappend LesInfos $Info
if {[OuiOuNonMemo "Je crée les répertoires ?" 0]} {
set HomeDir "/maison/esbs2016/$L"
if { ! [file exists $HomeDir]} { file mkdir "/maison/esbs2016/$L" }
if { ! [file exists /home/$L]} { exec ln -s $HomeDir /home/ }
}
lappend LeLdap "dn: uid=$L,ou=users,dc=lbgi,dc=fr"
lappend LeLdap "objectClass: inetOrgPerson"
lappend LeLdap "objectClass: posixAccount"
lappend LeLdap "cn: $L"
lappend LeLdap "sn: $N"
lappend LeLdap "givenName: $P"
lappend LeLdap "homeDirectory: /home/$L"
lappend LeLdap "loginShell: /usr/bin/tcsh"
lappend LeLdap "uidNumber: $UID"
lappend LeLdap "gidNumber: 3900"
lappend LeLdap "userPassword: $Hash"
lappend LeLdap ""
incr UID
}
SauveLesLignes $LesInfos dans "[HomeRipp]/Enseignement/ESBS2016/ToutPourESBS2016.txt"
set FichierLdap [SauveLesLignes $LeLdap dans "[HomeRipp]/Enseignement/ESBS2016/LdapPourESBS2016.txt"]
return $FichierLdap
}
proc CreateESBS2015 {} {
set UID 4001
set Hash [exec slappasswd -h "{SSHA}" -s esbs2015]
set LesInfos {}
set LeLdap {}
foreach Ligne [LesLignesDuFichier "[HomeRipp]/Enseignement/ESBS2015/ListeESBS2015.txt"] {
regsub -all {[ \t]+} $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
set L ""
lassign [split $Ligne " "] N P M L
if {$L==""} { set L [string tolower $N] }
set N [string toupper $N]
set Info "$L $P $N $UID 3115 esbs15 /home/$L esbs2015"
Espionne $Info
lappend LesInfos $Info
if {[OuiOuNonMemo "Je crée les répertoires ?" 0]} {
set HomeDir "/maison/esbs2015/$L"
if { ! [file exists $HomeDir]} { file mkdir "/maison/esbs2015/$L" }
if { ! [file exists /home/$L]} { exec ln -s $HomeDir /home/ }
}
lappend LeLdap "dn: uid=$L,ou=users,dc=lbgi,dc=fr"
lappend LeLdap "objectClass: inetOrgPerson"
lappend LeLdap "objectClass: posixAccount"
lappend LeLdap "cn: $L"
lappend LeLdap "sn: $N"
lappend LeLdap "givenName: $P"
lappend LeLdap "homeDirectory: /home/$L"
lappend LeLdap "loginShell: /usr/bin/tcsh"
lappend LeLdap "uidNumber: $UID"
lappend LeLdap "gidNumber: 3900"
lappend LeLdap "userPassword: $Hash"
lappend LeLdap ""
incr UID
}
SauveLesLignes $LesInfos dans "[HomeRipp]/Enseignement/ESBS2015/ToutPourESBS2015.txt"
set FichierLdap [SauveLesLignes $LeLdap dans "[HomeRipp]/Enseignement/ESBS2015/LdapPourESBS2015.txt"]
return $FichierLdap
}
proc CreateSAGE2016 {} {
set UID 3875
set GID 3016
set Hash [exec slappasswd -h "{SSHA}" -s 16sages]
set LesInfos {}
set LeLdap {}
set Rep "/maison/sage2016"
foreach Ligne [LesLignesDuFichier "[HomeRipp]/Enseignement/SAGE2016/SAGE2016.txt"] {
regsub -all {[ \t]+} $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
set L ""
lassign [split $Ligne " "] N P Id M L
if {$L==""} { set L [string tolower $N] }
set N [string toupper $N]
set Info "$L $P $N $UID $GID /home/$L"
Espionne $Info
if {[file exists "/home/$L"]} {
if {[OuiOuNon "On a déjà /home/$L\nJe garde l'ancien [file readlink /home/$L] ?"]} { incr UID ; continue }
}
if {[OuiOuNonMemo "Je crée les répertoires ?" 0]} {
set Maison "$Rep/$L"
file mkdir $Rep
file mkdir $Maison
exec chown $UID:$GID $Maison
NousAllonsAuBoulot /home
exec ln -s $Maison
Espionne [exec ls -l /home/$L]
OnRevientDuBoulot
}
lappend LesInfos $Info
lappend LeLdap "dn: uid=$L,ou=users,dc=lbgi,dc=fr"
lappend LeLdap "objectClass: inetOrgPerson"
lappend LeLdap "objectClass: posixAccount"
lappend LeLdap "cn: $L"
lappend LeLdap "sn: $N"
lappend LeLdap "givenName: $P"
lappend LeLdap "homeDirectory: /home/$L"
lappend LeLdap "loginShell: /usr/bin/tcsh"
lappend LeLdap "uidNumber: $UID"
lappend LeLdap "gidNumber: $GID"
lappend LeLdap "userPassword: $Hash"
lappend LeLdap ""
incr UID
}
SauveLesLignes $LesInfos dans "[HomeRipp]/Enseignement/SAGE2016/ToutPourSAGE2016.txt"
set FichierLdap [SauveLesLignes $LeLdap dans "[HomeRipp]/Enseignement/SAGE2016/LdapPourSAGE2016.txt"]
return $FichierLdap
}
proc CreateSAGE2017 {} {
set UID 3940
set GID 3017
set Hash [exec slappasswd -h "{SSHA}" -s 17sages]
set LesInfos {}
set LeLdap {}
set Rep "/maison/sage2017"
foreach Ligne [LesLignesDuFichier "[HomeRipp]/Enseignement/SAGE2017/SAGE2017.txt"] {
regsub -all {[ \t]+} $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
set L ""
lassign [split $Ligne " "] N P Id M L
if {$L==""} { set L [string tolower $N] }
set N [string toupper $N]
set Info "$L $P $N $UID $GID /home/$L"
Espionne $Info
if {[file exists "/home/$L"]} {
if {[OuiOuNon "On a déjà /home/$L\nJe garde l'ancien [file readlink /home/$L] ?"]} { incr UID ; continue }
}
if {[OuiOuNonMemo "Je crée les répertoires ?" 0]} {
set Maison "$Rep/$L"
file mkdir $Rep
file mkdir $Maison
exec chown $UID:$GID $Maison
NousAllonsAuBoulot /home
exec ln -s $Maison
Espionne [exec ls -l /home/$L]
OnRevientDuBoulot
}
lappend LesInfos $Info
lappend LeLdap "dn: uid=$L,ou=users,dc=lbgi,dc=fr"
lappend LeLdap "objectClass: inetOrgPerson"
lappend LeLdap "objectClass: posixAccount"
lappend LeLdap "cn: $L"
lappend LeLdap "sn: $N"
lappend LeLdap "givenName: $P"
lappend LeLdap "homeDirectory: /home/$L"
lappend LeLdap "loginShell: /usr/bin/tcsh"
lappend LeLdap "uidNumber: $UID"
lappend LeLdap "gidNumber: $GID"
lappend LeLdap "userPassword: $Hash"
lappend LeLdap ""
incr UID
}
SauveLesLignes $LesInfos dans "[HomeRipp]/Enseignement/SAGE2017/ToutPourSAGE2016.txt"
set FichierLdap [SauveLesLignes $LeLdap dans "[HomeRipp]/Enseignement/SAGE2017/LdapPourSAGE2017.txt"]
return $FichierLdap
}
proc CreateASM {} {
set UID 3845
set LesInfos {}
set LeLdap {}
foreach Ligne [LesLignesDuFichier "[HomeRipp]/Enseignement/ASM2014/LoginASM2014.txt"] {
regsub -all {[ \t]+} $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
set L ""
lassign [split $Ligne " "] N P L
if {$L==""} { set L [string tolower $N] }
set N [string toupper $N]
set Info "$L $P $N $UID 3114 asm14 /home/$L asm2014"
Espionne $Info
lappend LesInfos $Info
if {[OuiOuNonMemo "Je crée les répertoires ?" 0]} {
file mkdir "/maison/asm2014/$L"
}
lappend LeLdap "dn: uid=$L,ou=users,dc=lbgi,dc=fr"
lappend LeLdap "objectClass: inetOrgPerson"
lappend LeLdap "objectClass: posixAccount"
lappend LeLdap "cn: $L"
lappend LeLdap "sn: $N"
lappend LeLdap "givenName: $P"
lappend LeLdap "homeDirectory: /home/$L"
lappend LeLdap "loginShell: /usr/bin/tcsh"
lappend LeLdap "uidNumber: $UID"
lappend LeLdap "gidNumber: 3114"
lappend LeLdap "userPassword: {SSHA}1H8LEI+i4Pl7JuWJmoRW5VA0maeLU+UP"
lappend LeLdap ""
incr UID
}
SauveLesLignes $LesInfos dans "[HomeRipp]/Enseignement/ASM2014/ToutPourASM2014.txt"
set FichierLdap [SauveLesLignes $LeLdap dans "[HomeRipp]/Enseignement/ASM2014/LdapPourASM2014.txt"]
return $FichierLdap
}
proc CreateUserDir {{Rep ""}} {
if {$Rep==""} { set Rep "." }
foreach Ligne [split [exec ypcat passwd] "\n"] {
Espionne $Ligne
lassign [lrange [split $Ligne ":"] 0 2] Login bidon Uid
set UidDe($Login) $Uid
set LogDe($Uid) $Login
lappend LesLoginUid "$Login $Uid"
lappend LesUidLogin "$Uid $Login"
}
set LesUidLogin [lsort $LesUidLogin]
set LesLoginUid [lsort $LesLoginUid]
AfficheListe $LesUidLogin "" "LesUidLogin"
AfficheListe $LesLoginUid "" "LesLoginUid"
set Etudiants [NewUser "DontAsk" $Rep]
foreach Ligne [split $Etudiants "\n"] {
lassign [split $Ligne " "] L P N E M
lappend LesLogins $L
# set P [string range "$P[string toupper $N]" 3 10]
set P "2014esbs"
Espionne "$P $L"
# set S [string trim [exec htpasswd -nmb $L $P] " \n"]
set S "$L:"
append S {$6$8LDrNLVK$XkvEkFfmHYOnp82L0PfkE2lXZ88tuYaR23DeapNlt6O7Epp5VvNCU1aXErmtQqIsGunyfpq4ZJW/cO59bmxxK.}
set Shad "$S:16107:0:99999:7:::"
lappend LeShad $Shad
}
Sauve [join $LesLogins ","] dans "$Rep/loginsVirgule.txt"
SauveLesLignes $LeShad dans "$Rep/shad.txt"
if { ! [OuiOuNon "Je cree les repertoires"]} { exit }
set NextUid [Entre 3850]
foreach Ligne [split $Etudiants "\n"] {
while {[info exists LoginDe($NextUid)]} { incr NextUid }
lassign [split $Ligne " "] L P N E M
if {[info exists UidDe($L)]} { FaireLire "$L existe deja avec Uid $UidDe($L)"; continue }
set Home "/home/esbs2014/$L"
if { ! [file exists $Home]} { file mkdir $Home }
set N [string toupper $N]
set Pass "$L:x:$NextUid:3014:$P $N,,:/home/$L:/usr/bin/tcsh"
incr NextUid
lappend LePass $Pass
}
return [SauveLesLignes $LePass dasn "$Rep/pass.txt"]
}
proc NewUser {{Ask ""} {Rep ""}} {
set UseEnt 0
if {$Rep==""} { set Rep "." }
if {$Ask==""} { set Ask "Ask" }
set Ask [string equal -nocase "Ask" $Ask]
set Source "$Rep/liste.txt"
set SourceOk "$Rep/listeOk.txt"
if {[file exists $SourceOk]} {
set Texte [ContenuDuFichier $SourceOk]
set Bon $Texte
} else {
set Texte [ContenuDuFichier $Source]
regsub -all {[ \n\t\r]+} $Texte " " Texte
set Texte [string trim $Texte]
set LeBon {}
foreach {P N E M} [split $Texte " "] {
if {$UseEnt} {
regsub -all {[^a-z]} [string tolower $E] "" e
set L $e
} else {
regsub -all {[^a-z]} [string tolower $N] "" n
set L $n
}
lappend LeBon "$L $P $N $E $M"
}
set LeBon [lsort $LeBon]
set Bon [join $LeBon "\n"]
set Ask 1
}
set Ok $Bon
if {$Ask} { set Ok [EntreTexte $Ok "AvecRetour"] }
if {$Ok==""} { return "" }
if {$Ok!=$Texte} { Sauve $Ok dans $SourceOk }
return $Ok
}
proc CompareSources {DirA DirB {Action ""}} {
set LesMissingA {}
set LesMissingB {}
set LesCommuns {}
set LesDiff {}
set LesMemes {}
set LesA {}
set LesB {}
foreach A [lsort [glob -nocomplain "$DirA/*.tcl"]] {
set QA [file tail $A]
set ContenuA($QA) [ContenuDuFichier $A]
lappend LesQA $QA
lappend LesA $A
set FileA($QA) $A
}
foreach B [lsort [glob -nocomplain "$DirB/*.tcl"]] {
set QB [file tail $B]
set ContenuB($QB) [ContenuDuFichier $B]
lappend LesQB $QB
lappend LesB $B
set FileB($QB) $B
}
foreach QA $LesQA {
if { ! [info exists ContenuB($QA)]} { lappend LesMissingB $FileA($QA) ; continue}
lappend LesCommuns $QA
}
foreach QB $LesQB {
if { ! [info exists ContenuA($QB)]} { lappend LesMissingA $FileB($QB) ; continue}
}
foreach Q $LesCommuns {
if {$ContenuA($Q)==$ContenuB($Q)} { lappend LesMemes $Q ; continue }
lappend LesDiff $Q
}
AfficheListe $LesA "" "LesA"
AfficheListe $LesB "" "LesB"
AfficheListe $LesMissingA "" "LesMissingA"
AfficheListe $LesMissingB "" "LesMissingB"
AfficheListe $LesCommuns "" "LesCommuns"
AfficheListe $LesMemes "" "LesMemes"
while {1} {
set Zoom [AfficheListe $LesDiff "AvecRetour" "LesDiff"]
if {$Zoom==""} { break "" }
set A $FileA($Zoom)
set B $FileB($Zoom)
exec meld $A $B &
}
return ""
}
proc CatalogLinks {{Action ""} {File ""}} {
if {$File==""} {
set File [lindex [lsort [glob -nocomplain "/db/FromIGBMC/CatalogLinks*.txt"]] end]
}
NousAllonsAuBoulot "/db/catalog"
set LesCommandes [list "cd /db/catalog"]
foreach Ligne [LesLignesDuFichier $File] {
if { ! [regexp -nocase { ([^ ]+) \-> /(.+)$} $Ligne Match L T]} { continue }
set Commande "ln -s /db/$T $L"
if {$Action=="DoIt"} { eval exec $Commande }
lappend LesCommandes $Commande
}
OnRevientDuBoulot
if {$Action=="GetList"} { return $LesCommandes }
return [AfficheListe $LesCommandes]
}
proc RepOk {{Qui ""} {Set ""}} {
global RepOk
set FichierRepOk "/gstock/LogsRsync/RepOk.txt"
if {[info exists RepOk($Qui)]} { return $RepOk($Qui) }
if {[info exists RepOk("EstCharge")]} {
if {$Set=="set"} {
set RepOk($Qui) 1
set RepOk(List) [lsort -unique [lappend RepOk(List) $Qui]]
SauveLesLignes [array get RepOk] dans $FichierRepOk
return 1
}
return 0
}
set RepOk("EstCharge") 1
if {[file exists $FichierRepOk]} { array set RepOk [LesLignesDuFichier $FichierRepOk] }
set RepOk(List) [array names RepOk]
set RepOk("EstCharge") 1
return [RepOk $Qui $Set]
}
proc Proprio {{Qui ""} {Quoi ""}} {
global Proprio
if {[info exists Proprio($Qui,$Quoi)]} { return $Proprio($Qui,$Quoi) }
if {[info exists Proprio("EstCharge")]} { return "" }
set Proprio("EstCharge") 1
foreach Ligne [LesLignesDuFichier "/gstock/LogsRsync/proprios.txt"] {
regsub -all {[ \t]+} $Ligne " " Ligne
if { ! [regexp "^d" $Ligne]} { continue }
if { ! [regexp { /data[0-9]+/g[0-9]+} $Ligne]} { continue }
set LesMots [split $Ligne " "]
set O [lindex $LesMots 2]
set R [lindex $LesMots 7]
lappend Proprio(ListOf,O) $O
lappend Proprio(ListOf,R) $R
lappend Proprio(RepFrom,$O) $R
set Proprio(OwnerOf,$R) $O
}
set Proprio(ListOf,O) [lsort -unique $Proprio(ListOf,O)]
foreach O $Proprio(ListOf,O) {
lappend Proprio(Count,All) "[format %3d [llength $Proprio(RepFrom,$O)]] $O"
}
return [Proprio $Qui $Quoi]
}
proc RsyncGstock {{Qui ""} {Quoi ""}} {
global RsyncGstock
if {[info exists RsyncGstock($Qui,$Quoi)]} { return [join $RsyncGstock($Qui,$Quoi) "\n"] }
if {[info exists RsyncGstock("EstCharge")]} { return "" }
set RsyncGstock("EstCharge") 1
foreach Log [lsort -dictionary [glob -nocomplain "/gstock/LogsRsync/*.log"]] {
foreach Ligne [LesLignesDuFichier $Log] {
if { ! [regexp "^rsync\:" $Ligne] } { continue }
if { ! [regexp {failed to open \"([^\"]+)\"} $Ligne Match File] } { continue }
if { [file tail $File]=="core"} { continue }
if { ! [regexp {^(/data[0-9]+/g[0-9]+/[^/]+)/} $File Match R]} { continue }
if { [RepOk $R]} { continue }
set O [Proprio OwnerOf $R]
lappend RsyncGstock(ListOf,O) $O
lappend RsyncGstock(ListOf,File) $File
lappend RsyncGstock(RepFromOwner,$O) $R
lappend RsyncGstock(FilesFromOwner,$O) $File
lappend RsyncGstock(FilesFromRep,$R) $File
}
}
set RsyncGstock(ListOf,O) [lsort -unique $RsyncGstock(ListOf,O)]
foreach O $RsyncGstock(ListOf,O) {
set RsyncGstock(RepFromOwner,$O) [lsort -unique $RsyncGstock(RepFromOwner,$O)]
set RsyncGstock(NumberOfFilesFromOwner,$O) [llength $RsyncGstock(FilesFromOwner,$O)]
lappend RsyncGstock(Count,All) "[format %8d $RsyncGstock(NumberOfFilesFromOwner,$O)] $O"
}
set RsyncGstock(NumberOf,File) [llength $RsyncGstock(ListOf,File)]
return [RsyncGstock $Qui $Quoi]
}
proc CopieBiolo {} {
cd /biolo
foreach F [glob -nocomplain *] {
Espionne $F
if {[file exists "/commun/linux/biolo/$F"]} { continue }
if { ! [file isdirectory $F]} { continue }
if { ! [file readable $F]} { continue }
Espionne $F
if { ! [OuiOuNon "On traite $F "]} { continue }
catch {exec montar /biolo $F /commun/linux/biolo}
}
}
proc CilioBlastSummaryRR {Nom {GetWhat ""}} {
#rR attention ceci est pour CilioCode ou les enteteschevronnées sont des fois sans BId Acc (onsaute)
set LaSortie {}
set TousLesExpects {}
foreach Ligne [LesEntetesChevronneesDuBlast [GscopeFile $Nom "blastp"] "GetHeaders"] {
if { ! [regexp {>[^_]+_[^_]+ } $Ligne]} { continue } ; #rR on saute
regsub "^>" $Ligne "" Ligne
scan $Ligne "%s %s %s %s" BId Acc Genre Espece
set Orga "$Genre $Espece"
set Expect [StringApres "Expect=" dans $Ligne]
lappend TousLesExpects $Expect
if { ! [info exists Compte($Orga,Hits)]} {
lappend LesOrgas $Orga
set Compte($Orga,Hits) 0
set Compte($Orga,Repeats) 0
set Compte($Orga,Fragments) 0
set Compte($Orga,Uncharacterized) 0
set LesExpects($Orga) {}
}
incr Compte($Orga,Hits)
if {[regexp -nocase "repeat" $Ligne]} { incr Compte($Orga,Repeats) }
if {[regexp -nocase "fragment" $Ligne]} { incr Compte($Orga,Fragments) }
if {[regexp -nocase "uncharac" $Ligne]} { incr Compte($Orga,Uncharacterized) }
lappend LesExpects($Orga) $Expect
}
if {[regexp -nocase "Expect" $GetWhat]} { return $TousLesExpects }
if {[regexp -nocase "Orga" $GetWhat]} { return $LesOrgas }
if {[regexp -nocase "Graph" $GetWhat]} { return [Graphe $TousLesExpects "" "" "" "" "" "" "" "$Nom"] }
foreach Orga $LesOrgas {
set CiliaStatus [CiliaStatusOfOrga $Orga]
lappend LaSortie "[format %40s $Orga] [format %-12s $CiliaStatus] $Compte($Orga,Hits) $Compte($Orga,Repeats) $Compte($Orga,Fragments) $Compte($Orga,Uncharacterized) [join $LesExpects($Orga) { }]"
}
if {[regexp -nocase "Show" $GetWhat]} { return [AfficheListe $LaSortie "" "$Nom"] }
return $LaSortie
}
proc TfaAvecOrgaEnAccess {Fichier {Out ""}} {
foreach Ligne [LesLignesDuFichier $Fichier] {
if { [regexp {>.*\[(.*)\]} $Ligne Match Orga] } {
regsub -all " " $Orga "_" Orga
lappend LeNew ">$Orga"
continue
}
lappend LeNew $Ligne
}
if {$Out==""} { return [join $LeNew "\n"] }
return [SauveLesLignes $LeNew dans $Out]
}
proc MontageDesSmall {} {
exec montage -geometry +0+0 -tile 10 \
AspRS_Decline.1.1-Crop-Small.png \
AspRS_Decline.2.1-Crop-Small.png \
AspRS_Decline.3.1-Crop-Small.png \
AspRS_Decline.4.1-Crop-Small.png \
AspRS_Decline.5.1-Crop-Small.png \
AspRS_Decline.6.1-Crop-Small.png \
AspRS_Decline.7.1-Crop-Small.png \
AspRS_Decline.8.1-Crop-Small.png \
AspRS_Decline.9.1-Crop-Small.png \
AspRS_Decline.10.1-Crop-Small.png \
AspRS_Decline.1.2-Crop-Small.png \
AspRS_Decline.2.2-Crop-Small.png \
AspRS_Decline.3.2-Crop-Small.png \
AspRS_Decline.4.2-Crop-Small.png \
AspRS_Decline.5.2-Crop-Small.png \
AspRS_Decline.6.2-Crop-Small.png \
AspRS_Decline.7.2-Crop-Small.png \
AspRS_Decline.8.2-Crop-Small.png \
AspRS_Decline.9.2-Crop-Small.png \
AspRS_Decline.10.2-Crop-Small.png \
AspRS_Decline.1.3-Crop-Small.png \
AspRS_Decline.2.3-Crop-Small.png \
AspRS_Decline.3.3-Crop-Small.png \
AspRS_Decline.4.3-Crop-Small.png \
AspRS_Decline.5.3-Crop-Small.png \
AspRS_Decline.6.3-Crop-Small.png \
AspRS_Decline.7.3-Crop-Small.png \
AspRS_Decline.8.3-Crop-Small.png \
AspRS_Decline.9.3-Crop-Small.png \
AspRS_Decline.10.3-Crop-Small.png \
AspRS_Decline-Crop-Small.png
}
proc MontageDesCrop {} {
exec montage -geometry +0+0 -tile 10 \
AspRS_Decline.1.1-Crop.png \
AspRS_Decline.2.1-Crop.png \
AspRS_Decline.3.1-Crop.png \
AspRS_Decline.4.1-Crop.png \
AspRS_Decline.5.1-Crop.png \
AspRS_Decline.6.1-Crop.png \
AspRS_Decline.7.1-Crop.png \
AspRS_Decline.8.1-Crop.png \
AspRS_Decline.9.1-Crop.png \
AspRS_Decline.10.1-Crop.png \
AspRS_Decline.1.2-Crop.png \
AspRS_Decline.2.2-Crop.png \
AspRS_Decline.3.2-Crop.png \
AspRS_Decline.4.2-Crop.png \
AspRS_Decline.5.2-Crop.png \
AspRS_Decline.6.2-Crop.png \
AspRS_Decline.7.2-Crop.png \
AspRS_Decline.8.2-Crop.png \
AspRS_Decline.9.2-Crop.png \
AspRS_Decline.10.2-Crop.png \
AspRS_Decline.1.3-Crop.png \
AspRS_Decline.2.3-Crop.png \
AspRS_Decline.3.3-Crop.png \
AspRS_Decline.4.3-Crop.png \
AspRS_Decline.5.3-Crop.png \
AspRS_Decline.6.3-Crop.png \
AspRS_Decline.7.3-Crop.png \
AspRS_Decline.8.3-Crop.png \
AspRS_Decline.9.3-Crop.png \
AspRS_Decline.10.3-Crop.png \
AspRS_Decline-Crop.png
}
proc ResizeEtMontageDesCrops {{Racine ""} {Ext ""} {Resize ""}} {
if {$Resize==""} { set Resize "10%" }
if {$Ext==""} { set Ext "png" }
foreach Fichier [glob "$Racine.*.*.png"] {
set RX "$Racine\.(\[0-9\]+)\.(\[0-9\]+)\-Crop\.$Ext$"
if { ! [regexp $RX $Fichier Match X Y]} { continue }
set ImageDe($X,$Y) $Fichier
lappend LesX $X
lappend LesY $Y
}
set LesX [lsort -integer $LesX]
set LesY [lsort -integer $LesY]
foreach Y $LesY {
foreach X $LesX {
set Source $ImageDe($X,$Y)
regsub "\.$Ext" $Source "-Small.$Ext" Destin
set Destin "Small/$Destin"
exec convert -resize $Resize $Source $Destin
lappend LesDestin $Destin
}
}
return $LesDestin
}
proc CropLesAlignements {{Racine ""} {Ext ""}} {
if {$Ext==""} { set Ext "png" }
foreach Fichier [glob "$Racine.*.*.png"] {
set RX "$Racine\.(\[0-9\]+)\.(\[0-9\]+)\.$Ext$"
if { ! [regexp $RX $Fichier Match X Y]} { continue }
set ImageDe($X,$Y) $Fichier
lappend LesX $X
lappend LesY $Y
}
set LesX [lsort -integer $LesX]
set LesY [lsort -integer $LesY]
set PremierX [lindex $LesX 0]
set PremierY [lindex $LesY 0]
set DernierX [lindex $LesX end]
set DernierY [lindex $LesY end]
foreach Y $LesY {
set CropYHaut 10
set CropYBas 710
if {$Y==$PremierY} { set CropYHaut 0 }
if {$Y==$DernierY} { set CropYBas 823 }
foreach X $LesX {
set CropXGauche 113
set CropXDroit 1103
if {$X==$PremierX} { set CropXGauche 0 }
if {$X==$DernierX} { set CropXDroit 1306 }
set w [expr $CropXDroit - $CropXGauche]
set h [expr $CropYBas - $CropYHaut]
set Source $ImageDe($X,$Y)
regsub "\.$Ext" $Source "-Crop.$Ext" Destin
set Destin "./Crop/$Destin"
exec convert -crop ${w}x${h}+$CropXGauche+$CropYHaut $Source $Destin
lappend LesDestin $Destin
}
}
return $LesDestin
}
proc RenommeLesCopiesDEcrans {{Racine ""}} {
foreach Fichier [glob "AspRS_Decline.*.*.jpeg"] {
if { ! [regexp {AspRS_Decline\.([0-9]+)\.([0-9]+)\.jpeg$} $Fichier Match X Y]} { continue }
set New "AspRS_Decline-$Y-$X.jpg"
file copy $Fichier $New
lappend LesNew $New
}
return $LesNew
}
proc RRRRRCanvasDuBlastToSvg {FileBlast {FileSvg ""}} {
set K [IllustreLeBlast $FileBlast]
if {$FileSvg == ""} { set FileSvg "[TmpFile Blastp].svg" }
set svg [CanvasToSvgFile $K GetSvg]
# TODO id-> data
regsub -all {id=} $svg "class=" svg
return $svg
}
proc TestCanvasToSvgFile {} {
# set K [GscopeBoard]
package require Tk
LogWscope coucoucoucoucouc
set K [IllustreLeBlast "/genomics/link/CilioCarta2014/blastp/CIL006"]
LogWscope $K
return [CanvasToSvgFile $K "GetSvg"]
}
proc TestCanvasToSvgFileSvg {} {
package require Tk
set K [IllustreLeBlastSvg]
return [CanvasToSvgFile $K "GetSvg"]
}
proc CanvasToSvgFile {K {File ""}} {
if {$File==""} { set File "./CanvasToSvgFile.svg" }
source "[GscopeContrib]/moumou/tinyfileutils.tcl"
source "[GscopeContrib]/moumou/uriencode.tcl"
source "[GscopeContrib]/moumou/can2svg.tcl"
package require can2svg
set Svg [can2svg::canvas2file $K $File]
if {$File=="GetSvg"} { return $Svg }
return $File
}
proc PhylogenicBarcode {{UniprotId ""}} {
set Host [LbgiHost]
set Php "http://$Host/barcode/server.php"
set Url "$Php?stype=update_barcode&colorset=global&labels=true&values=false&grid=true"
append Url "&uniprotid=$UniprotId"
return ContenuDuFichier $Url
}
proc MobyleConfig {{Qui ""} {Quoi ""}} {
global MobyleConfig
if {[regexp -nocase "ResetAll" $Qui]} {
if {[info exists MobyleConfig]} { unset MobyleConfig }
return
}
if {[info exists MobyleConfig($Qui,$Quoi)]} { return $MobyleConfig($Qui,$Quoi) }
if {[info exists MobyleConfig("EstCharge")]} { return "" }
set MobyleConfig("EstCharge") 1
set FichierConfig "[MobDir]/core/Local/Config/Config.py"
set MobyleConfig(FileName,) $FichierConfig
set Content [ContenuDuFichier $FichierConfig]
set MobyleConfig(Content,) $Content
regsub -all {\#[^\n]+\n} $Content "\n" Content
set P1 ""; set P2 ""; set P3 ""; set V1 ""; set V2 ""; set V3 "";
set R [regexp -all -inline -nocase {\nLOCAL_DEPLOY_(INCLUDE|EXCLUDE)[\s\n]*=[\s\n]*\{([^\}]+)\}} $Content]
foreach {Match IE A} $R {
regsub -all {[\'\s\n]+} $A " " A
set A [string trim $A]
set PVs [regexp -all -inline -nocase {([a-z]+) \: \[([^\]]+)\] ,} $A]
foreach {Match P V} $PVs {
regsub -all {[ \,\'\n]+} $V " " V ; set LesV [split [string trim $V] " "]
lappend MobyleConfig($IE,ListOf) $P
set MobyleConfig($IE,$P) $LesV
foreach V $LesV {
set MobyleConfig($V,) $IE
}
}
}
return [MobyleConfig $Qui $Quoi]
}
proc MobyleBlastDatabase {{Action ""}} {
if {$Action==""} { set Action "Usage" }
if {$Action=="Usage"} {
set LesActions [list \
Usage \
ProGet \
ProList \
ProXmlShow \
ProXmlCreate \
ProXmlFilename \
NucGet \
NucList \
NucXmlShow \
NucXmlCreate \
NucXmlFilename \
]
set Actions [join $LesActions "\n"]
return $Actions
}
if { ! [regexp -nocase {(Pro|Nuc)} $Action Match]} {
return "Sorry, you have to specify Pro or Nuc.\n[MobyleBlastDatabase Usage]"
}
set X $Match
set Motif "TrululuLalere"
if {$X=="Pro"} {
set FichierXml "[MobDir]/core/Local/Services/Programs/Entities/protdbs.xml"
set Motif "Local/Services/Programs/Entities/protdbs.xml"
} else {
set FichierXml "[MobDir]/core/Local/Services/Programs/Entities/nucdbs.xml"
set Motif "Local/Services/Programs/Entities/nucdbs.xml"
}
if {[regexp -nocase "Filename" $Action]} { return $FichierXml }
if {[regexp -nocase "Show" $Action]} { return [ContenuDuFichier $FichierXml] }
set Date [Date Nice]
set LeXml {}
lappend LeXml "<vlist>"
lappend LeXml " <velem undef=\"1\">"
lappend LeXml " <value>null</value>"
lappend LeXml " <label>Choose a database (LBGI $Date)</label>"
lappend LeXml " </velem>"
set Dir [BlastDatabaseInventory "Dir"]
foreach BT [split [BlastDatabaseInventory "ListOf" "${X}BestFirstWithTitle"] "\n"] {
scan $BT "%s" B
lappend LaListe $B
set T [StringSuivant ":" dans $BT]
lappend LeXml " <velem>"
lappend LeXml " <value>$Dir/$B</value>"
lappend LeXml " <label>$BT</label>"
lappend LeXml " </velem>"
}
lappend LeXml "</vlist>"
set Xml [join $LeXml "\n"]
if {[regexp -nocase "List" $Action]} {
return [join $LaListe "\n"]
}
if {[regexp -nocase "Create" $Action]} {
Garde $FichierXml
set FX [Sauve $Xml dans $FichierXml]
if {[regexp -nocase "Deploy" $Action]} {
set LesToDeploy [glob -nocomplain "[MobDir]/core/Services/Programs/*.xml"]
foreach F $LesToDeploy {
set C [ContenuDuFichier $F]
if { ! [regexp $Motif $C]} { continue }
set Q [file tail $F]
regsub ".xml$" $Q "" P
lappend LesP $P
}
set ProgsToDeploy [join $LesP ","]
Espionne $ProgsToDeploy ; exit
exec [HomeRipp]/Mob/core/Tools/mobdeploy -s local -p $ProgsToDeploy deploy
return "$ProgsToDeploy \n were deployed with\n$FX"
}
return $FX
}
#rR arrive ici on doit avoir Get"
return $Xml
}
proc DpkgShow {} {
set LesH [Dpkg All ListOf H]
set LesA [Dpkg All ListOf A]
foreach P [Dpkg All ListOf P] {
set LesX {}
set HostManquant 0
foreach H $LesH A $LesA {
set X $A
if {[Dpkg $H $P P]==""} { set HostManquant 1; set X " " }
lappend LesX $X
}
if { $HostManquant} { lappend LesDistincts "[join $LesX {}] $P" }
if { ! $HostManquant} { lappend LesCommuns "[join $LesX {}] $P" }
}
set Hosts [join $LesH " "]
AfficheListe $LesDistincts "" "$Hosts diff"
AfficheListe $LesCommuns "" "$Hosts idem"
}
proc Dpkg {{Host ""} {Qui ""} {Quoi ""}} {
global Dpkg
if {[info exists Dpkg($Host,$Qui,$Quoi)]} { return $Dpkg($Host,$Qui,$Quoi) }
if {[info exists Dpkg("EstCharge")]} { return "" }
set Dpkg("EstCharge") 1
cd "[HomeRipp]/sys/pkg"
set LesH [list "ena" "studio" "moby" "eyear" "virturr" "virtuwr"]
set LesA [list "A" "S" "M" "E" "R" "W"]
foreach H $LesH {
set OnAttend 1
foreach Ligne [LesLignesDuFichier "dpkg.$H.txt"] {
if {$OnAttend && ! [regexp {^\+\+\+} $Ligne]} { continue }
if {$OnAttend && [regexp {^\+\+\+} $Ligne]} { set OnAttend 0; continue }
scan $Ligne "%s %s %s" S P V
lappend LesP $P
set D [string trim [StringSuivant $V dans $Ligne]]
set Dpkg($H,$P,A) $Ligne
set Dpkg($H,$P,I) $P
set Dpkg($H,$P,P) $P
set Dpkg($H,$P,V) $Ligne
set Dpkg($H,$P,D) $Ligne
lappend Dpkg(All,ListOf,P) $P
lappend Dpkg($H,ListOf,P) $P
}
}
set Dpkg(ListOf,A,) $LesA
set Dpkg(ListOf,H,) $LesH
set Dpkg(All,ListOf,H) $LesH
set Dpkg(All,ListOf,P) [lsort -unique $Dpkg(All,ListOf,P)]
return [Dpkg $Host $Qui $Quoi]
}
proc TcpDump Commande {
set Fichier "TcpDump"
set PidTcpDump [exec tcpdump -s 0 -i any -w $Fichier &]
afte 100
eval exec $Commande
exec kill -9 PidTcpDump
return $Fichier
}
proc ListOfGenesWith {Key Value args} {
set LesR {}
foreach Nom [ListeDesPABs] {
set K "$Key:"
set V [ExtraitInfo $Nom $K]
if {[regexp {^RX_(.*)} $Value Match VV]} {
if { ! [regexp $VV $V]} { continue }
} else {
if {$V!=$Value} { continue }
}
set R $Nom
if {$args=={}} { lappend LesR $Nom ; continue }
set LesInfos {}
foreach I $args {
lappend LesInfos [ExtraitInfo $Nom $I]
}
lappend LesR [join $LesInfos "\t"]
}
set LesR [lsort -unique $LesR]
return $LesR
}
proc TexteUT TexteOuFichier {
set Texte $TexteOuFichier
if {[regexp "/" $TexteOuFichier]} { set Texte [ContenuDuFichier $TexteOuFichier] }
set New ""
foreach Mot [LesMotsDuTexte $Texte] {
set X [UT $Mot]
append New $X
}
return $New
}
proc RemoveLesLiensModellerDansPython {{Action ""}} {
if {$Action==""} { set Action "Show" }
set Filtre "/usr/lib/python*/dist-packages/*modeller*"
Espionne $Filtre
set LesLinks {}
foreach Link [lsort [glob -nocomplain "/usr/lib/python*/dist-packages/*modeller*"]] {
Espionne $Link
if {$Action=="Remove"} { file delete $Link }
lappend LesLinks $Link
}
return $LesLinks
}
proc SimpleFasta {{FicIn ""} {FicOu ""} {Ask ""}} {
set Ask [string equal -nocase "Ask" $Ask]
if {$FicIn==""} { set FicIn [ButineArborescence] }
if {$FicOu==""} {
set FicOu $FicIn
regsub {\.tfa$} $FicOu "" FicOu
set FicOu "$FicIn.new.tfa"
}
set LeNew {}
foreach Ligne [LesLignesDuFichier $FicIn] {
if { ! [regexp ">" $Ligne]} { lappend LeNew $Ligne ; continue }
regsub {^>gi\|} $Ligne ">" Ligne
regsub {^>} $Ligne "" Ligne
regsub -all {\|} $Ligne " " Ligne
scan $Ligne "%s" Access
regsub "^$Access " $Ligne "" Ligne
if {[regexp {\[([^\]]+)\]$} $Ligne Match OS]} {
regsub {\([^\)]+\) } $OS "" OS ; #rR pour enlever cette merde de (Silurana)
set G "" ; set E ""
scan $OS "%s %s" G E
set OS "$G $E"
if {[info exists Petit($OS)]} {
set Gesp $Petit($OS)
} else {
set G1 [string index $G 0]
set i 2
set Esp [string range $E 0 $i]
set Gesp [string totitle "$G1$Esp"]
while {[info exists DejaVu($Gesp)]} {
if { ! $Ask} {
incr i
if {$i>=[string length $E]} { append Gesp "x" ; continue }
set Esp [string range $E 0 $i]
set Gesp [string totitle "$G1$Esp"]
continue
}
FaireLire "Trying to find a short name for $OS\n\
I already saw $Gesp for $DejaVu($Gesp). \n\
Please tell me what I have to use for $OS"
set Gesp [Entre $OS]
}
set DejaVu($Gesp) $OS
set Petit($OS) $Gesp
}
append Access "_$Gesp"
}
set Ligne ">$Access $Ligne"
lappend LeNew $Ligne
if {[string equal -nocase $FicOu "Show"]} { Espionne $Ligne }
}
if {[string equal -nocase $FicOu "Show"]} { return "I dodn't create anny output." }
return [SauveLesLignes $LeNew dasn $FicOu]
}
proc GenemapKey {} {
set Texte "
1 - Numbering system, in the format Chromosome.Map_Entry_Number
2 - Month entered
3 - Day entered
4 - Year entered
5 - Cytogenetic location
6 - Gene Symbols
7 - Gene Status
8 - Title
9 - Title, cont.
10 - MIM Number
11 - Method
12 - Comments
13 - Comments, cont.
14 - Disorders each disorder is followed by its MIM number, if
different from that of the locus, and phenotype mapping method (see
below. Allelic disorders are separated by a semi-colon.
15 - Disorders, cont.
16 - Disorders, cont.
17 - Mouse correlate
18 - Reference"
return $Texte
}
proc GenesFromOmimHitsFromFile {{File ""} {WithinGeneList ""}} {
set WithAllGenes 1
if {$WithinGeneList!=""} {
set WithAllGenes 0
if {[llength $WithinGeneList]==1 && [file exists $WithinGeneList]} {
set WithinGeneList [LesLignesDuFichier $WithinGeneList]
}
foreach Ligne $WithinGeneList {
regsub -all {[ \,/]+} $Ligne " " Ligne
foreach Gn [split [string trim $Ligne] " "] {
set GN [string toupper $Gn]
set WithGene($GN) 1
lappend LesGN $GN
}
}
set LesGN [lsort -unique $LesGN]
FaireLire "il y a [llength $LesGN] genes differents dans $WithinGeneList"
}
set LaSortie {}
foreach O [OmimHitsFromFile $File "ListOf" "O"] {
foreach Gn [MorbidMap $O "Gn"] {
lappend LesGn $Gn
lappend LesOduGn($Gn) $O
}
}
set LesGn [lsort -unique $LesGn]
foreach Gn $LesGn {
if { ! $WithAllGenes } {
set GN [string toupper $Gn]
if { ! [info exists WithGene($GN)]} { continue }
}
set LesOduGn($Gn) [lsort -unique $LesOduGn($Gn)]
foreach O $LesOduGn($Gn) {
set Dis [join [MorbidMap $O "Di"] " /// "]
lappend LaSortie "$Gn\t$O\t$Dis"
}
}
return $LaSortie
}
proc OmimHitsFromFile {{File ""} {Qui ""} {Quoi ""}} {
global OmimHitsFromFile
set FileIn $File
if {$File==""} {
if { ! [info exists OmimHitsFromFile("CurrentFile")]} {
set File "[HomeRipp]/ImAnnoWww/ImAnno/ImAnnoTeeth/Virginie/OmimHitsForTeeth.txt"
} else {
set File $OmimHitsFromFile("CurrentFile")
}
}
set OmimHitsFromFile("CurrentFile") $File
if {$Qui=="" && $Quoi==""} { set Qui "ListOf"; set Quoi "O" }
if {[info exists OmimHitsFromFile($File,$Qui,$Quoi)]} { return $OmimHitsFromFile($File,$Qui,$Quoi) }
if {[info exists OmimHitsFromFile($File,,EstCharge)]} { return "" }
set OmimHitsFromFile($File,,EstCharge) 1
set LesO {}
foreach Ligne [LesLignesDuFichier $File] {
if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
if {[regexp {^(.)([0-9]+)} $Ligne Match T O]} {
lappend LesO $O
lappend LesTypesDe($O) $T
lappend LaDescriDe($O) [string range $Ligne 1 end]
continue
}
lappend LaDescriDe($O) [string trim $Ligne]
}
set LesO [lsort -unique $LesO]
set OmimHitsFromFile($File,ListOf,O) $LesO
foreach O $LesO {
set OmimHitsFromFile($File,DescriptionOf,$O) [join $LaDescriDe($O) " /// "]
set OmimHitsFromFile($File,TypeOf,$O) [join $LesTypesDe($O) " /// "]
}
return [OmimHitsFromFile $FileIn $Qui $Quoi]
}
proc MorbidMapFromList {List {Quoi ""} {JoinCar ""} {RecordsJoinCar ""} {ListJoinCar ""} {WithinHits ""}} {
#rR List peut etre un nom de fichier (avec /), une liste ou un texte avec ,
#rR Peut etre une liste de numeros OMIM ou un fichier (avec un /) contenant de OmimHits
set WithAllHits 1
if {$WithinHits!=""} {
set WithAllHits 0
if {[regexp "/" $WithinHits] && [file exists $WithinHits]} {
set WithinHits [OmimHitsFromFile $WithinHits "ListOf" "O"]
}
foreach O $WithinHits {
set WithHit($O) 1
}
}
set WithoutEmpty [regexp -nocase "WithoutEmpty" $Quoi]
if {$WithoutEmpty} { regsub -nocase "WithoutEmpty" $Quoi "" Quoi }
if {$RecordsJoinCar=="Tab"} { set RecordsJoinCar "\t" }
if {[regexp "/" $List] && [file exists $List]} {
set L {}
foreach Ligne [LesLignesDuFichier $List] {
scan $Ligne "%s" G
lappend L $G
}
set List $L
}
if {[regexp "\," $List]} { set List [split $List ","] }
set LeRetour {}
foreach Qui $List {
set MM [MorbidMap $Qui $Quoi]
if { ! $WithAllHits} {
#rR j'ai greffe cette verrue pour ne prendre que les O qui sont dans WithinHits
#rR on suppose que O se trouve toujours en début (en fait Quoi doit etre O ou OD)
set GoodMM {}
foreach H $MM {
scan $H "%s" O
if {[info exists WithHit($O)]} { lappend GoodMM $H }
}
set Avant [llength $MM]; set Apres [llength $GoodMM]
set MM $GoodMM
}
if {$JoinCar!=""} { set MM [join $MM $JoinCar] }
if {$MM=="" && $WithoutEmpty} { continue }
set Ligne [list $Qui $MM]
if {$RecordsJoinCar!=""} { set Ligne [join $Ligne $RecordsJoinCar] }
lappend LeRetour $Ligne
}
if {$ListJoinCar!=""} { set LeRetour [join $LeRetour $ListJoinCar] }
return $LeRetour
}
proc MorbidMap {{Qui ""} {Quoi ""}} {
global MorbidMap
if {$Qui==""} { return "" }
# if {$Qui==""} { set Qui "ListOf" ; set Quoi "Gn" }
if {$Quoi==""} { set Quoi "OD" } ; #rR on rend Omim et Disease 2012/0525
if {$Quoi=="Disease"} { set Quoi "Di" }
if {$Qui!="ListOf"} { set Qui [string toupper $Qui] }
if {[info exists MorbidMap($Qui,$Quoi)]} { return $MorbidMap($Qui,$Quoi) }
if {[info exists MorbidMap("EstCharge")]} { return "" }
set MorbidMap("EstCharge") 1
set RepKb "/genomics/link/AmdKb"
set FichierMorbidMap "$RepKb/DeSM2PH/morbidmap.txt"
set Ix -1
foreach Ligne [LesLignesDuFichier $FichierMorbidMap] {
incr Ix
regsub -all {[\{\}@]} $Ligne "" Ligne
regsub -all { +} $Ligne " " Ligne
regsub -all { *\| *} $Ligne "|" Ligne
set Ligne [string trim $Ligne]
lassign [split $Ligne "|"] Di Genes Om Cy
if { ! [regexp { ([0-9]{6}) \([0-9]\)$} $Di Match O2]} { set O2 "" }
regsub -all {[ ,]+} $Genes " " Genes
set LesGenes [split [string trim $Genes] " "]
set MorbidMap($Ix,Line) $Ligne
lappend MorbidMap(ListOf,Ix) $Ix
lappend MorbidMap($Di,Ix) $Ix
lappend MorbidMap($Om,Ix) $Ix
lappend MorbidMap(ListOf,Di) $Di
lappend MorbidMap(ListOf,Om) $Om
if {$O2!=""} {
lappend MorbidMap($O2,Ix) $Ix
lappend MorbidMap(ListOf,Om) $O2
}
foreach Gn $LesGenes {
lappend MorbidMap(ListOf,Gn) $Gn
lappend MorbidMap($Gn,Ix) $Ix
lappend MorbidMap($Gn,Di) $Di
lappend MorbidMap($Gn,Cy) $Cy
lappend MorbidMap($Gn,Om) $Om
lappend MorbidMap($Gn,OD) "$Om $Di"
lappend MorbidMap($Om,Gn) $Gn
if {$O2!=""} {
lappend MorbidMap($Gn,Om) $O2
lappend MorbidMap($Gn,OD) "$O2 $Di"
lappend MorbidMap($O2,Gn) $Gn
}
}
lappend MorbidMap($Di,Om) $Om
lappend MorbidMap($Om,Di) $Di
lappend MorbidMap($Om,Cy) $Cy
if {$O2!=""} {
lappend MorbidMap($Di,Om) $O2
lappend MorbidMap($O2,Di) $Di
lappend MorbidMap($O2,Cy) $Cy
}
}
set MorbidMap(ListOf,Gn) [lsort -unique $MorbidMap(ListOf,Gn)]
set MorbidMap(ListOf,Di) [lsort -unique $MorbidMap(ListOf,Di)]
set MorbidMap(ListOf,Om) [lsort -unique $MorbidMap(ListOf,Om)]
foreach Gn $MorbidMap(ListOf,Gn) {
set MorbidMap($Gn,Ix) [lsort -unique $MorbidMap($Gn,Ix)]
set MorbidMap($Gn,Di) [lsort -unique $MorbidMap($Gn,Di)]
set MorbidMap($Gn,Cy) [lsort -unique $MorbidMap($Gn,Cy)]
set MorbidMap($Gn,Om) [lsort -unique $MorbidMap($Gn,Om)]
set MorbidMap($Gn,OD) [lsort -unique $MorbidMap($Gn,OD)]
}
foreach Om $MorbidMap(ListOf,Om) {
set MorbidMap($Om,Ix) [lsort -unique $MorbidMap($Om,Ix)]
set MorbidMap($Om,Di) [lsort -unique $MorbidMap($Om,Di)]
set MorbidMap($Om,Cy) [lsort -unique $MorbidMap($Om,Cy)]
set MorbidMap($Om,Gn) [lsort -unique $MorbidMap($Om,Gn)]
}
return [MorbidMap $Qui $Quoi]
}
proc OmimGenemapFromList {List {Quoi ""} {JoinCar ""} {RecordsJoinCar ""} {ListJoinCar ""} {WithinHits ""}} {
#rR ressemble furieusement a MorbidMapFromList
#rR List peut etre un nom de fichier (avec /), une liste ou un texte avec ,
#rR Peut etre une liste de numeros OMIM ou un fichier (avec un /) contenant de OmimHits
set WithAllHits 1
if {$WithinHits!=""} {
set WithAllHits 0
if {[regexp "/" $WithinHits] && [file exists $WithinHits]} {
set WithinHits [OmimHitsFromFile $WithinHits "ListOf" "O"]
}
foreach O $WithinHits {
set WithHit($O) 1
}
}
set WithoutEmpty [regexp -nocase "WithoutEmpty" $Quoi]
if {$WithoutEmpty} { regsub -nocase "WithoutEmpty" $Quoi "" Quoi }
if {$RecordsJoinCar=="Tab"} { set RecordsJoinCar "\t" }
if {[regexp "/" $List] && [file exists $List]} {
set L {}
foreach Ligne [LesLignesDuFichier $List] {
scan $Ligne "%s" G
lappend L $G
}
set List $L
}
if {[regexp "\," $List]} { set List [split $List ","] }
set LeRetour {}
foreach Qui $List {
set GM [OmimGenemap $Qui $Quoi]
#rR attention GM peut etre une liste separee par des /// que je transfome en @
while {[regsub -all "///" $GM "@" GM]} {}
set LesGM [split $GM "@"]
if { ! $WithAllHits} {
#rR j'ai greffe cette verue pour ne prendre que les O qui sont dans WithinHits
#rR on suppose que O se trouve toujours en début (en fait Quoi doit etre O ou OD)
set GoodGM {}
foreach H $LesGM {
scan $H "%s" O
if {[info exists WithHit($O)]} { lappend GoodGM $H }
}
set Avant [llength $GM]; set Apres [llength $GoodGM]
set LesGM $GoodGM
}
#rR attention GM peut etre une liste separee par des ///
if {$JoinCar!=""} { set GM [join $LesGM $JoinCar] }
if {$GM=="" && $WithoutEmpty} { continue }
set Ligne [list $Qui $GM]
if {$RecordsJoinCar!=""} { set Ligne [join $Ligne $RecordsJoinCar] }
lappend LeRetour $Ligne
}
if {$ListJoinCar!=""} { set LeRetour [join $LeRetour $ListJoinCar] }
return $LeRetour
}
proc OmimGenemap {{Qui ""} {Quoi ""}} {
global OmimGenemap
if {$Qui==""} { return "" }
# if {$Qui==""} { set Qui "ListOf" ; set Quoi "Gn" }
if {$Quoi==""} { set Quoi "Di" }
if {$Quoi=="Disease"} { set Quoi "Di" }
if {$Qui!="ListOf"} { set Qui [string toupper $Qui] }
if {[info exists OmimGenemap($Qui,$Quoi)]} { return $OmimGenemap($Qui,$Quoi) }
if {[info exists OmimGenemap($Qui,Omims)]} {
set LeResultat [list]
foreach Omim $OmimGenemap($Qui,Omims) {
if {[info exists OmimGenemap($Omim,$Quoi)] && $OmimGenemap($Omim,$Quoi)!=""} {
lappend LeResultat $OmimGenemap($Omim,$Quoi)
}
}
set LeResultat [lsort -unique $LeResultat]
return [join $LeResultat "///"]
}
if {[info exists OmimGenemap("EstCharge")]} { return "" }
set OmimGenemap("EstCharge") 1
set RepKb "/genomics/link/AmdKb"
set FichierOmimGenemap "$RepKb/DeSM2PH/genemap.txt"
set KeysOri [list CI ME DE YE Cy GNs GS Ti1 Ti2 Omim Me Co1 Co2 Di1 Di2 Di3 MM Ref]
set Keys [list CI Date Cy GNs GS Ti Omim Me Co Di MM Ref]
set OmimGenemap(ListOf,Keys) $Keys
foreach Ligne [LesLignesDuFichier $FichierOmimGenemap] {
regsub -all {[\{\}@]} $Ligne "" Ligne
regsub -all { +} $Ligne " " Ligne
regsub -all { *\| *} $Ligne "|" Ligne
set Ligne [string trim $Ligne]
set Values [split $Ligne "|"]
lassign $Values CI ME DE YE Cy GNs GS Ti1 Ti2 Omim Me Co1 Co2 Di1 Di2 Di3 MM Ref
if {$YE>55} { set YE "19$YE" } else { set YE "20$YE" }
regsub "^0" $ME "" ME
regsub "^0" $DE "" DE
if {$ME==""} { set ME "0" }
if {$DE==""} { set DE "0" }
set Date [format "%4.4d%2.2d%2.2d" $YE $ME $DE]
set Ti $Ti1
if {$Ti2!=""} { append Ti " $Ti2" }
set Co $Co1
if {$Co2!=""} { append Co " $Co2" }
set Di $Di1
if {$Di2!=""} { append Di " $Di2" }
if {$Di3!=""} { append Di " $Di3" }
set OmimGenemap($Omim,Line) $Ligne
regsub -all " +" $GNs "" GNs
set OmimGenemap($Omim,CI) $CI
set OmimGenemap($Omim,Date) $Date
set OmimGenemap($Omim,Cy) $Cy
set OmimGenemap($Omim,GNs) $GNs
set OmimGenemap($Omim,GS) $GS
set OmimGenemap($Omim,Ti) $Ti
set OmimGenemap($Omim,Omim) $Omim
set OmimGenemap($Omim,Me) $Me
set OmimGenemap($Omim,Co) $Co
set OmimGenemap($Omim,Di) $Di
set OmimGenemap($Omim,MM) $MM
set OmimGenemap($Omim,Ref) $Ref
lappend OmimGenemap($CI,Omims) $Omim
foreach K $Keys {
lappend OmimGenemap(ListOf,$K) $OmimGenemap($Omim,$K)
}
foreach Gn [split $GNs ","] {
lappend OmimGenemap(ListOf,Gn) $Gn
lappend OmimGenemap($Gn,Omims) $Omim
}
}
lappend OmimGenemap(ListOf,Keys) "Line"
foreach K $Keys {
set OmimGenemap(ListOf,$K) [lsort -unique $OmimGenemap(ListOf,$K)]
}
set OmimGenemap(ListOf,Gn) [lsort -unique $OmimGenemap(ListOf,Gn)]
return [OmimGenemap $Qui $Quoi]
}
proc SM2PHKB {{Kb ""} {GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "GetList" }
if {$Kb==""} { set Kb "YourFavoriteDirectory" }
if {[regexp "/" $Kb]} { set RepKb $Kb } else { set RepKb "/genomics/link/$Kb" }
while {[FileAbsent $RepKb]} {
set RepKb [ChoixDuRepertoire $RepKb]
}
if {$GetWhat=="SaveList"} { set GetWhat "$RepKb/ListOfAcces.txt" }
set FichierListGene "$RepKb/DeSM2PH/list_gene.txt"
LoadTxl $FichierListGene TLG 1 "\t"
set RepEmbl "$RepKb/proteome"
file mkdir $RepEmbl
foreach Gn $TLG(ListOf,Index) {
set Access $TLG($Gn,Proteins)
set LeEmbl [LaSequenceDesBanques $Access]
if {$LeEmbl=={}} { FaireLire "I can't find $Access" ; continue }
lappend LesAccess $Access
# SauveLesLignes $LeEmbl dans "$RepEmbl/$Access"
}
if {[regexp {[/\.]} $GetWhat]} { return [SauveLesLignes $LesAccess dans $GetWhat] }
return $LesAccess
}
proc Sm2PhPhenotype {{Qui ""} {Quoi ""}} {
global Sm2PhPhenotype
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Omim" }
if {$Quoi==""} { set Quoi "Phenotype" }
if {$Qui!="ListOf"} { set Qui [string toupper $Qui] }
if {[info exists Sm2PhPhenotype($Qui,$Quoi)]} { return $Sm2PhPhenotype($Qui,$Quoi) }
if {[info exists Sm2PhPhenotype($Qui,Omims)]} {
set LeResultat {}
foreach Omim $Sm2PhPhenotype($Qui,Omims) {
if {[info exists Sm2PhPhenotype($Omim,$Quoi)]} { lappend LeResultat $Sm2PhPhenotype($Omim,$Quoi) }
}
set LeResultat [lsort -unique $LeResultat]
return [join $LeResultat "///"]
}
if {[info exists Sm2PhPhenotype("EstCharge")]} { return "" }
set Sm2PhPhenotype("EstCharge") 1
set RepKb "/genomics/link/AmdKb"
set FichierListPhenotype "$RepKb/DeSM2PH/20000_list_phenotype.txt"
LoadTxl $FichierListPhenotype LPh 1 "\t"
foreach Omim $LPh(ListOf,Index) {
set Ph [string trim $LPh($Omim,Phenotype)]
set Gn [string trim [StringSuivant "; " dans $Ph]]
if {[regexp " " $Gn]} { FaireLire "bad Gn in $Ph" }
if {[info exists Sm2PhPhenotype($Ph,Omims)]} {
# FaireLire "DejaVu $Ph $Sm2PhPhenotype($Ph,Omims) \n [set Sm2PhPhenotype([set Sm2PhPhenotype($Ph,Omims)],Phenotype)]"
}
set LP $LPh($Omim,Proteins)
regsub -all {[ ,]+} $LP " " LP
set LP [split [string trim $LP] " "]
foreach P $LP {
lappend Sm2PhPhenotype(ListOf,Protein) $P
lappend Sm2PhPhenotype($P,Omim) $Omim
lappend Sm2PhPhenotype($P,Phenotype) $Ph
lappend Sm2PhPhenotype($Omim,Proteins) $P
}
lappend Sm2PhPhenotype(ListOf,Omim) $Omim
lappend Sm2PhPhenotype(ListOf,Phenotype) $Ph
set Sm2PhPhenotype($Omim,Phenotype) $Ph
set Sm2PhPhenotype($Omim,Genename) $Gn
lappend Sm2PhPhenotype($Ph,Omims) $Omim
if {$Gn!=""} {
lappend Sm2PhPhenotype(ListOf,Genename) $Gn
lappend Sm2PhPhenotype($Gn,Omims) $Omim
}
}
unset LPh
set Sm2PhPhenotype(ListOf,Phenotype) [lsort -unique $Sm2PhPhenotype(ListOf,Phenotype)]
set Sm2PhPhenotype(ListOf,Protein) [lsort -unique $Sm2PhPhenotype(ListOf,Protein)]
set Sm2PhPhenotype(ListOf,Genename) [lsort -unique $Sm2PhPhenotype(ListOf,Genename)]
return [Sm2PhPhenotype $Qui $Quoi]
}
proc HumanMutationDisease {{Qui ""} {Quoi ""}} {
global HumanMutationDisease
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Gn" }
if {$Quoi==""} { set Quoi "Di" }
if {$Quoi=="Disease"} { set Quoi "Di" }
if {$Qui!="ListOf"} { set Qui [string toupper $Qui] }
if {[info exists HumanMutationDisease($Qui,$Quoi)]} { return $HumanMutationDisease($Qui,$Quoi) }
if {[info exists HumanMutationDisease($Qui,Ix)]} {
set LeResultat {}
foreach Ix $HumanMutationDisease($Qui,Ix) {
if {[info exists HumanMutationDisease($Ix,$Quoi)]} { LConcat LeResultat $HumanMutationDisease($Ix,$Quoi) }
}
set LeResultat [lsort -unique $LeResultat]
return [join $LeResultat "///"]
}
if {[info exists HumanMutationDisease("EstCharge")]} { Espionne $Qui; return "" }
set HumanMutationDisease("EstCharge") 1
set RepKb "/genomics/link/AmdKb"
set FichierHumanMutationDisease "$RepKb/DeSM2PH/humsavar.txt"
set Ix -1
foreach Ligne [LesLignesDuFichier $FichierHumanMutationDisease] {
incr Ix
set HumanMutationDisease($Ix,Line) $Ligne
set Gn [set Ac ""]
scan $Ligne "%s %s %s %s %s %s" Gn Ac Id Mu VT Rs
if {$Gn=="" || $Ac==""} { continue }
set Di [string range $Ligne 74 end]
set Om ""
regexp {\[MIM\:([^\]]+)\]} $Di Match Om
lappend HumanMutationDisease($Ix,Ix) $Ix
lappend HumanMutationDisease($Ix,Gn) $Gn
lappend HumanMutationDisease($Ix,Ac) $Ac
lappend HumanMutationDisease($Ix,Id) $Id
lappend HumanMutationDisease($Ix,VT) $VT
lappend HumanMutationDisease($Ix,Rs) $Rs
lappend HumanMutationDisease($Ix,Di) $Di
lappend HumanMutationDisease($Ix,Om) $Om
lappend HumanMutationDisease($Ix,AM) "$Ac $Mu"
lappend HumanMutationDisease(ListOf,Ix) $Ix
lappend HumanMutationDisease(ListOf,Gn) $Gn
lappend HumanMutationDisease(ListOf,Ac) $Ac
lappend HumanMutationDisease(ListOf,Id) $Id
lappend HumanMutationDisease(ListOf,VT) $VT
lappend HumanMutationDisease(ListOf,Rs) $Rs
lappend HumanMutationDisease(ListOf,Di) $Di
lappend HumanMutationDisease(ListOf,Om) $Om
lappend HumanMutationDisease(ListOf,AM) "$Ac $Mu"
if {[info exists HumanMutationDisease($Ac,Gn)] && $HumanMutationDisease($Ac,Gn)!=$Gn} {
#rR ne sert pas (theoriquement) !
FaireLire "$Ac $Gn $HumanMutationDisease($Ac,Gn)"
}
set HumanMutationDisease($Ac,Gn) $Gn
lappend HumanMutationDisease($Ac,Ix) $Ix
lappend HumanMutationDisease($Ac,Mu) $Mu
lappend HumanMutationDisease($Ac,Di) $Di
lappend HumanMutationDisease($Ac,Om) $Om
lappend HumanMutationDisease($Ac,Rs) $Rs
lappend HumanMutationDisease($Ac,VT) $VT
lappend HumanMutationDisease($Gn,Ac) $Ac
lappend HumanMutationDisease($Gn,Ix) $Ix
lappend HumanMutationDisease($Gn,AM) "$Ac $Mu"
lappend HumanMutationDisease($Gn,Di) $Di
lappend HumanMutationDisease($Gn,Om) $Om
lappend HumanMutationDisease($Gn,Rs) $Rs
lappend HumanMutationDisease($Gn,VT) $VT
lappend HumanMutationDisease($Om,Ix) $Ix
}
set HumanMutationDisease(ListOf,Gn) [lsort -unique $HumanMutationDisease(ListOf,Gn)]
set HumanMutationDisease(ListOf,Ac) [lsort -unique $HumanMutationDisease(ListOf,Ac)]
set HumanMutationDisease(ListOf,Id) [lsort -unique $HumanMutationDisease(ListOf,Id)]
set HumanMutationDisease(ListOf,VT) [lsort -unique $HumanMutationDisease(ListOf,VT)]
set HumanMutationDisease(ListOf,Rs) [lsort -unique $HumanMutationDisease(ListOf,Rs)]
set HumanMutationDisease(ListOf,Di) [lsort -unique $HumanMutationDisease(ListOf,Di)]
set HumanMutationDisease(ListOf,Om) [lsort -unique $HumanMutationDisease(ListOf,Om)]
set HumanMutationDisease(ListOf,AM) [lsort -unique $HumanMutationDisease(ListOf,AM)]
foreach Gn $HumanMutationDisease(ListOf,Gn) {
set HumanMutationDisease($Gn,Di) {}
foreach Ac $HumanMutationDisease($Gn,Ac) {
LConcat HumanMutationDisease($Gn,Di) $HumanMutationDisease($Ac,Di)
}
set HumanMutationDisease($Gn,AM) [lsort -unique $HumanMutationDisease($Gn,AM)]
set HumanMutationDisease($Gn,Rs) [lsort -unique $HumanMutationDisease($Gn,Rs)]
set HumanMutationDisease($Gn,VT) [lsort -unique $HumanMutationDisease($Gn,VT)]
set HumanMutationDisease($Gn,Di) [lsort -unique $HumanMutationDisease($Gn,Di)]
set HumanMutationDisease($Gn,Di) [join $HumanMutationDisease($Gn,Di) "\n"]
}
foreach Ac $HumanMutationDisease(ListOf,Ac) {
set HumanMutationDisease($Ac,Mu) [lsort -unique $HumanMutationDisease($Ac,Mu)]
set HumanMutationDisease($Ac,Rs) [lsort -unique $HumanMutationDisease($Ac,Rs)]
set HumanMutationDisease($Ac,VT) [lsort -unique $HumanMutationDisease($Ac,VT)]
set HumanMutationDisease($Ac,Di) [lsort -unique $HumanMutationDisease($Ac,Di)]
set HumanMutationDisease($Ac,Di) [join $HumanMutationDisease($Ac,Di) "\n"]
}
return [HumanMutationDisease $Qui $Quoi]
}
proc LOPPI {pf} {
set L [LongueurDeLaSequence $pf "prottfa"]
set O [nombreCaracteristiqueAnalyse $pf "orthologie"]
set P [nombreCaracteristiqueAnalyse $pf "pdb"]
set F [nombreCaracteristiqueAnalyse $pf "pfam"]
set I [nombreCaracteristiqueAnalyse $pf "interaction"]
return "$L $O $P $F $I"
}
proc IdAcGnForList {{Liste ""} {Quoi ""} {Orga ""} {GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "GetList" }
if {[regexp {[ \,\;\n]} $Liste]} {
set Liste [regsub -all {[ \,\;\n]+} $Liste ","]
set Liste [string trim $Liste]
set Liste [split $Liste ","]
}
if {$Liste=="AllId"} { set Liste [IdAcGn $Orga "ListOf" "Id"] }
if {$Liste=="AllAc"} { set Liste [IdAcGn $Orga "ListOf" "Ac"] }
if {$Liste=="AllGn"} { set Liste [IdAcGn $Orga "ListOf" "Gn"] }
set R {}
foreach Qui $Liste {
set W [list $Qui]
foreach Q [split $Quoi ","] {
if {$Q=="Qu"} {
set X $Qui
} else {
set X [IdAcGn $Orga $Qui $Q]
}
regsub -all " " $X "," X
lappend W $X
}
lappend R [join $W ":"]
}
if {$GetWhat=="GetList"} { return $R }
if {$GetWhat=="GetLines"} { return [join $R "\n"] }
return [join $R "/"]
}
proc IdAcGn {{Orga ""} {Qui ""} {Quoi ""}} {
global IdAcGn
regsub " " $Orga "_" Orga
if {$Orga==""} { set Orga "Homo_sapiens" }
# if {$Orga==""} { set Orga "Saccharomyces_cerevisiae" }
set Save 0
set Test 0
if {$Orga=="Test"} { set Test 1; set Save 0; set Orga "Homo_sapiens" }
if {$Orga=="Save"} { set Test 1; set Save 1; set Orga "Homo_sapiens" }
set FileName "[GscopeDatabaseDir Common]/fiches/IdAcGn_$Orga.txt"
set SaveName "[GscopeDatabaseDir Common]/fiches/IdAcGn_$Orga-Save.txt"
if {$Qui=="ReLoad"} {
if {[file exists $SaveName]} { file delete $SaveName }
if {[info exists IdAcGn]} { unset IdAcGn }
set Qui "SaveName"
}
if {[info exists IdAcGn($Orga,$Qui,$Quoi)]} { return $IdAcGn($Orga,$Qui,$Quoi) }
if {[info exists IdAcGn("EstCharge")]} {
set QUI [string toupper $Qui]
if {[info exists IdAcGn($Orga,$QUI,$Quoi)]} { return $IdAcGn($Orga,$QUI,$Quoi) }
return ""
}
set IdAcGn("EstCharge") 1
set IdAcGn($Orga,FileName,) $FileName
set IdAcGn($Orga,SaveName,) $SaveName
if { ! $Test && [file exists $IdAcGn($Orga,SaveName,)]} {
array set IdAcGn [LesLignesDuFichier $IdAcGn($Orga,SaveName,)]
return [IdAcGn $Orga $Qui $Quoi]
}
set Id "ID_UNKNOWN"; set Ac "AC_UNKNOWN"; set Gn "GN_UNKNOWN"
set I 0
foreach Ligne [LesLignesDuFichier $IdAcGn($Orga,FileName,)] {
set Ligne [string toupper $Ligne]
set LigneOriginale $Ligne
regsub -all {[ ;]+} $Ligne " " Ligne
set Ligne [string trim $Ligne]
set LesMots [split $Ligne " "]
lassign $LesMots K V1 V2 V3
if {$K eq "//"} {
incr I
if {0 && [incr I]> 333} { break } ;#rR attention on teste ici !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
lappend LesId $Id
LConcat LesAc $LesA
lappend LesGn $Gn
lappend LesLe $Le
set IdAcGn($Orga,$Id,Id) $Id
set IdAcGn($Orga,$Id,Le) $Le
set IdAcGn($Orga,$Id,Gn) $Gn
set IdAcGn($Orga,$Id,Acs) $LesA
set Ac [lindex $LesA 0]
set IdAcGn($Orga,$Id,Ac) $Ac
if {[info exists DejaVu($Id)]} { FaireLire "$Id $Ac deja vu pour $DejaVu($Id)" }
foreach A $LesA {
if {[info exists DejaVu($A)]} { lappend IdAcGn($Orga,Ambiguous,Ac) "$A $Id $Gn already seen in : $DejaVu($A)" }
lappend DejaVu($A) "$Id $Gn"
}
set DejaVu($Id) $Ac
lappend IdAcGn($Orga,$Gn,LeId) "$Le $Id"
lappend IdAcGn($Orga,$Gn,Ids) $Id
lappend IdAcGn($Orga,$Le,Ids) $Id
foreach A $LesA {
set IdAcGn($Orga,$A,Ac) $A
set IdAcGn($Orga,$A,Id) $Id
set IdAcGn($Orga,$A,Gn) $Gn
lappend IdAcGn($Orga,$A,Ids) $Id
lappend IdAcGn($Orga,$A,Gns) $Gn
lappend IdAcGn($Orga,$Gn,Acs) $A
}
set Id "ID_UNKNOWN"; set Ac "AC_UNKNOWN"; set Gn "GN_UNKNOWN"
continue
}
if {$K eq "ID"} { set Id $V1; set Le $V3; continue }
if {$K eq "AC"} {
set LesA [lrange $LesMots 1 end]
if {[llength $LesA]>6} {
set LesBonsA {}
foreach A $LesA {
if {[string length $A]>6} {
lappend LesBonsA [string range $A 0 5] [string range $A 5 end]
} else {
lappend LesBonsA $A
}
}
set LesA $LesBonsA
}
}
if {$K eq "GN"} {
set Gn $V1
regsub "NAME=" $Gn "" Gn
regsub -all "/" $Gn "-" Gn
regsub -all {[^a-zA-Z0-9_\-\+]} $Gn "" Gn
set LesS {}
if {[regexp {SYNONYMS=([^;]+);} $LigneOriginale Match Synonyms]} {
if {$Gn=="ERGIC3"} { Espionne "$LigneOriginale" }
regsub -all {[ /\,;]+} $Synonyms " " Synonyms ;#rR / devient separateur
set LesSynonyms [split [string trim $Synonyms] " "]
if {$Gn=="ERGIC3"} { Espionne $LesSynonyms }
foreach Sy $LesSynonyms {
regsub -all {[^a-zA-Z0-9_\.\-\+]} $Sy "" Sy
lappend LesS $Sy
if {[info exists IdAcGn($Orga,$Sy,GnOfSy)]} {
#rR attention on ne teste plus rien si on l'a deja rencontre
# if {$IdAcGn($Orga,$Sy,GnOfSy)==$Gn} { continue }
# FaireLire "DejaVuSynonym $Sy de $Gn mais pour $IdAcGn($Orga,$Sy,GnOfSy)"
continue
}
set IdAcGn($Orga,$Sy,GnOfSy) $Gn
lappend LesSy $Sy
}
set IdAcGn($Orga,$Gn,Sys) $LesSynonyms
}
set LesO {}
if {[regexp {ORFNAMES=([^;]+);} $LigneOriginale Match OrfNames]} {
regsub -all {[ /\,;]+} $OrfNames " " OrfNames ;#rR / devient separateur
set LesOrfNames [split [string trim $OrfNames] " "]
foreach On $LesOrfNames {
regsub -all {[^a-zA-Z0-9_\.\-\+]} $On "" On
lappend LesO $On
if {[info exists IdAcGn($Orga,$On,GnOfOn)]} {
#rR attention on ne teste plus rien si on l'a deja rencontre
# if {$IdAcGn($Orga,$On,GnOfOn)==$On} { continue }
# FaireLire "DejaVuSynonym $On de $Gn mais pour $IdAcGn($Orga,$On,GnOfOn)"
continue
}
set IdAcGn($Orga,$On,GnOfOn) $Gn
lappend LesOn $On
}
set IdAcGn($Orga,$Gn,Ons) $LesOrfNames
}
}
}
set IdAcGn($Orga,ListOf,On) [lsort -unique $LesOn]
set IdAcGn($Orga,ListOf,Sy) [lsort -unique $LesSy]
set IdAcGn($Orga,ListOf,Id) [lsort -unique $LesId]
set IdAcGn($Orga,ListOf,Ac) [lsort -unique $LesAc]
set IdAcGn($Orga,ListOf,Gn) [lsort -unique $LesGn]
set IdAcGn($Orga,ListOf,Le) [lsort -unique -integer $LesLe]
set IdAcGn($Orga,NumberOf,Id) $I
set IdAcGn($Orga,NumberOf,Ac) [llength $IdAcGn($Orga,ListOf,Ac)]
foreach Gn $IdAcGn($Orga,ListOf,Gn) {
set IdAcGn($Orga,$Gn,LeId) [lsort -decreasing -command CompareLesIntegersEnDebut $IdAcGn($Orga,$Gn,LeId)]
set LeId [lindex $IdAcGn($Orga,$Gn,LeId) 0]
scan $LeId "%d %s" Le Id
set Ac $IdAcGn($Orga,$Id,Ac)
set IdAcGn($Orga,$Gn,Gn) $Gn
set IdAcGn($Orga,$Gn,Le) $Le
set IdAcGn($Orga,$Gn,Id) $Id
set IdAcGn($Orga,$Gn,Ac) $Ac
lappend IdAcGn($Orga,ListOf,MajorId) $Id
lappend IdAcGn($Orga,ListOf,MajorAc) $Ac
}
foreach Sy $IdAcGn($Orga,ListOf,Sy) {
if {[info exists IdAcGn($Orga,$Sy,Id)]} { continue }
set Gn $IdAcGn($Orga,$Sy,GnOfSy) ;#rR attention on rajoute les synonymes aux Gn
set IdAcGn($Orga,$Sy,Gn) $Sy
set IdAcGn($Orga,$Sy,Le) $IdAcGn($Orga,$Gn,Le)
set IdAcGn($Orga,$Sy,Id) $IdAcGn($Orga,$Gn,Id)
set IdAcGn($Orga,$Sy,Ac) $IdAcGn($Orga,$Gn,Ac)
lappend IdAcGn($Orga,ListOf,Gn) $Sy
}
foreach On $IdAcGn($Orga,ListOf,On) {
if {[info exists IdAcGn($Orga,$On,Id)]} { continue }
set Gn $IdAcGn($Orga,$On,GnOfOn) ;#rR attention on rajoute les OrfNames aux Gn
set IdAcGn($Orga,$On,Gn) $On
set IdAcGn($Orga,$On,Le) $IdAcGn($Orga,$Gn,Le)
set IdAcGn($Orga,$On,Id) $IdAcGn($Orga,$Gn,Id)
set IdAcGn($Orga,$On,Ac) $IdAcGn($Orga,$Gn,Ac)
lappend IdAcGn($Orga,ListOf,Gn) $On
}
set IdAcGn($Orga,ListOf,Gn) [lsort -unique $IdAcGn($Orga,ListOf,Gn)]
set IdAcGn($Orga,NumberOf,Gn) [llength $IdAcGn($Orga,ListOf,Gn)]
set IdAcGn($Orga,GN_UNKNOWN,Id) "ID_UNKNOWN"
set IdAcGn($Orga,GN_UNKNOWN,Ac) "AC_UNKNOWN"
set IdAcGn($Orga,GN_UNKNOWN,Gn) "GN_UNKNOWN"
set IdAcGn($Orga,ID_UNKNOWN,Id) "ID_UNKNOWN"
set IdAcGn($Orga,ID_UNKNOWN,Ac) "AC_UNKNOWN"
set IdAcGn($Orga,ID_UNKNOWN,Gn) "GN_UNKNOWN"
set IdAcGn($Orga,AC_UNKNOWN,Id) "ID_UNKNOWN"
set IdAcGn($Orga,AC_UNKNOWN,Ac) "AC_UNKNOWN"
set IdAcGn($Orga,AC_UNKNOWN,Gn) "GN_UNKNOWN"
set Tout [array get IdAcGn]
if { $Save } { SauveLesLignes $Tout dans $IdAcGn($Orga,SaveName,) }
return [IdAcGn $Orga $Qui $Quoi]
}
proc IdAcGnCreateFile {{OsVoulu ""} } {
regsub -all " " $OsVoulu "_" OsVoulu
set Fichier "[GscopeDatabaseDir Common]/fiches/IdAcGn_$OsVoulu.txt_NEW"
set LeResume {}
foreach Ligne [LesLignesDuFichier "/diki/stock/GeneQuid/Uniprot/uniprot_sprot.dat"] {
set K [string range $Ligne 0 4]
if {$K eq "ID "} { set Id $Ligne ; continue }
if {$K eq "AC "} { set Ac $Ligne ; continue }
if {$K eq "GN "} { set Gn $Ligne ; continue }
if {$K eq "OS "} { set Os $Ligne ; continue }
if {$K ne "//" } { continue }
regsub { \(.+$} $Os "" Os
regsub -all " " $Os "_" OsUnderscore
if {$OsUnderscore eq "OS___$OsVoulu"} {
if {$Id ne ""} { lappend LeResume $Id }
if {$Ac ne ""} { lappend LeResume $Ac }
if {$Gn ne ""} { lappend LeResume $Gn }
if {$Os ne ""} { lappend LeResume $Os }
lappend LeResume "//"
}
set Id "" ; set Ac "" ; set Gn "" ; set Os ""
}
return [SauveLesLignes $LeResume dans $Fichier]
}
proc LesIdMappingUniprot {Liste {GetWhat ""} {Field ""}} {
if {[llength $Liste]==1 && [file exists $Liste]} { set Liste [LesLignesDuFichier $Liste] }
if {$GetWhat==""} { set GetWhat "GetQR" }
if {[regexp {[ \,\;\n\r\t]} $Liste]} { set Liste [split $Liste " ,;\n\r\t"] }
if {$Field==""} { set Field "ACC" }
set LesRecus [IDMapping "ACC+ID" $Field $Liste]
foreach Q $Liste R $LesRecus {
if {$R==""} { lappend LesR $R }
lappend LesQR "$Q:$R"
}
if {[regexp -nocase "GetR" $GetWhat]} { set Result $LesR }
if {[regexp -nocase "GetQR" $GetWhat]} { set Result $LesQR }
if {[regexp -nocase "AsTextWithSpace" $GetWhat]} { set Result [join $Result " "] }
if {[regexp -nocase "AsTextWithComma" $GetWhat]} { set Result [join $Result ","] }
if {[regexp -nocase "AsTextWithNewLine" $GetWhat]} { set Result [join $Result "\n"] }
return $Result
}
proc AcGnDeDesAccess {{FichierOuLesAccess ""} {FichierSortie ""}} {
if {[llength $FichierOuLesAccess]==1 && [file exists $FichierOuLesAccess]} {
set LesAccess {}
foreach Access [LesLignesDuFichier $FichierOuLesAccess] {
regsub -nocase {[^A-Z0-9\-_].*} $Access "" Access
lappend LesAccess $Access
}
} else {
set LesAccess $FichierOuLesAccess
}
# if {$LesAccess==""} { set LesAccess {C9K029 D3DX37 D3DX38 P0C7P4 P47985 Q13546 Q6ZNS2 Q8NBI3 Q8TCM3 Q96LT6 Q9NX33} }
set I 0
while { $I < [llength $LesAccess]} {
set LesA [lrange $LesAccess $I [expr [incr I 100] - 1]]
foreach A $LesA G [GenenameDesAccess $LesA] D [DescriptionDesAccess $LesA] {
lappend LeR "$A;$G;$D"
}
Espionne "$I $A;$G;$D"
}
if {$FichierSortie!=""} { return [SauveLesLignes $LeR dans $FichierSortie] }
return $LeR
}
proc DescriptionDesAccess {Liste {GetWhat ""} {Database ""} } {
if {$Database==""} { set Database "uniprot" }
if {$GetWhat==""} { set GetWhat "ListOfDE" }
set LesAD {}
set LesADfull {}
set LesDE {}
set LesDEfull {}
foreach Ligne $Liste {
if { ! [regexp -nocase {[a-z]} $Ligne]} {continue}
scan $Ligne "%s" Access
set DE [BirdWeb $Database $Access "DE"]
lappend LesADfull $Access $DE
lappend LesDfull $DE
regsub {\;.*} $DE "" DE
if {[regexp {=(.+)} $DE Match Def]} { set DE $Def }
lappend LesAD $Access $DE
if {$DE!=""} { lappend LesDE $DE }
}
if {[string equal -nocase "ListOfDE" $GetWhat]} { return $LesDE }
if {[string equal -nocase "ListOfAD" $GetWhat]} { return $LesAD }
if {[string equal -nocase "ListOfDful" $GetWhat]} { return $LesDfull }
if {[string equal -nocase "ListOfADful" $GetWhat]} { return $LesADfull }
if {[string equal -nocase "ListOfDful" $GetWhat]} { return $LesDfull }
return $LesADfull
}
proc GenenameDesAccess {Liste {GetWhat ""} {Database ""} } {
if {$Database==""} { set Database "uniprot" }
if {$GetWhat==""} { set GetWhat "ListOfGN" }
set LesAG {}
set LesGN {}
if {[regexp {[ \,\;\n\t]} $Liste]} {
regsub -all {[ \,\;\n\t]+} $Liste "," Liste
set Liste [split [string trim $Liste ","] ","]
}
foreach Ligne $Liste {
if { ! [regexp -nocase {[a-z]} $Ligne]} {continue}
scan $Ligne "%s" Access
set GN [BirdWeb $Database $Access "GN"]
regsub {\;.*} $GN "" GN
if {[regexp {=(.+)} $GN Match Name]} { set GN $Name }
lappend LesAG $Access $GN
lappend LesAeG "$Access=$GN"
if {$GN!=""} { lappend LesGN $GN }
}
set R $LesAG
if {[regexp -nocase "ListOfAeG" $GetWhat]} { set R $LesAeG }
if {[regexp -nocase "ListOfGN" $GetWhat]} { set R $LesGN }
if {[regexp -nocase "AsText" $GetWhat]} { return [join $R ","] }
return $R
}
proc LesProcsEnDouble {{Meld ""}} {
set Meld [string equal -nocase $Meld "Meld"]
foreach F [LesSourcesDeGscope] {
if { ! [regexp ".tcl$" $F]} { continue }
if {[regexp "chalmel|jmuller" $F]} { continue }
Espionne $F
set F "[HomeRipp]/gscope/$F"
foreach Ligne [LesLignesDuFichier $F] {
if { ! [regexp {^proc ([^ ]+) } $Ligne Match P]} { continue }
lappend LesSourcesDe($P) $F
}
}
foreach {P Fs} [array get LesSourcesDe] {
if {[info proc $P]==""} { continue }
if {[llength $Fs]==1} { continue }
set Egal ""
if {[llength $Fs]==2} {
set F1 [lindex $Fs 0]
if {[catch {source $F1}] } { continue }
set A1 [info args $P]
set S1 [info body $P]
set S1 "$A1\n$S1"
set F2 [lindex $Fs 1]
if {[catch {source $F2}] } { continue}
set A2 [info args $P]
set S2 [info body $P]
set S2 "$A2\n$S2"
Espionne "=$P=\n[join $Fs \n]\n"
if {$P=="AttriDesAcDna"} {
break
Espionne "\n\n\n$S1\n\n\n"
Espionne "\n\n\n$S2\n\n\n"
}
if {$S1==$S2} {
set Egal "Ce sont les memes"
} else {
if {$Meld} {
set T1 "[TmpFile][file tail $F1]"
set T2 "[TmpFile][file tail $F2]"
Sauve $S1 dans $T1
Sauve $S2 dans $T2
exec meld $T1 $T2
# FaireLire "Clique ici quand tu auras comparer les deux"
file delete $T1
file delete $T2
}
}
}
lappend LesDoubles "\n$P\n[join $Fs \n]\n$P $Egal\n"
}
return [AfficheListe $LesDoubles]
}
proc BeauDessin {} {
set K [UnCanva]
$K create rectangle 100 100 200 300 -fill "red"
pack $K
}
proc Memory {} {
set V [string repeat "A" 1000000]
FaireLire "Je vais remplir la memoire"
for {set i 0} {$i<1000000} {incr i} {
set T($i) $V
}
FaireLire "Je vais vider la memoire"
array unset T
update idletasks
FaireLire "J'ai vide la memoire"
exit
}
proc RajoutEnFinDesLignesDuFichier {Fichier Rajout {Sortie ""}} {
if {$Sortie=="GetList"} { set Sortie "" }
set LeNew {}
foreach Ligne [LesLignesDuFichier $Fichier] {
lappend LeNew "$Ligne$Rajout"
}
if {$Sortie!=""} { return [SauveLesLignes $LeNew dans $Sortie] }
if {$Sortie=="GetText"} { return [join $LeNew "\n"] }
return $LeNew
}
#http://zoom.gwdg.de/?obj=iip%2C1.0&wid=600&fif=022%2FES00000469_00006B.fpx&cvt=jpeg
#http://zoom.gwdg.de/?fif=022%2FES00000469_00015B.fpx&obj=iip,1.0&wid=5745&cvt=JPEG
proc testExec {} {
puts [package require Pgtcl]
return [exec tcsh -c "setgscoperr Zero -q ; gscope puts ListeDesPABs"]
}
proc EvolHHuProDir {} {
return "[HomeRipp]/EvolHHuPro"
}
proc KinaseBarcode {} {
cd [EvolHHuProDir]
foreach Ligne [LesLignesDuFichier "kinase_bilan.lst"] {
set X ""
set Y "unk"
scan $Ligne "%s %s %s %s %s %s" K A E B X Y
if {$X==""} { continue }
set Xde($K) $X
set Yde($K) $Y
}
foreach Ligne [LesLignesDuFichier "barcode.txt"] {
set K ""
scan $Ligne "%s" K
if {$K==""} { continue }
if {[info exists Xde($K)]} {
set N [join [list $Xde($K) $Yde($K) $K] "_"]
regsub $K $Ligne $N New
lappend LeNew $New
} else {
lappend LeNew $Ligne
}
}
return [SauveLesLignes $LeNew dans "KinaseBarcode.txt"]
}
proc RenommeFichiers {Qui Avant Apres {Option ""} {Comment ""}} {
if {$Comment==""} { set Comment "Demander" }
foreach Fichier [glob -nocomplain $Qui] {
if {$Option==""} {
set Allons [regsub $Avant $Fichier $Apres Nouveau]
} else {
set Allons [regsub $Option $Avant $Fichier $Apres Nouveau]
}
if { ! $Allons } { continue }
lappend LesAvAp $Fichier $Nouveau
}
set Retour [AfficheListe $LesAvAp "AvecRetour"]
set LesAvAp [split $Retour "\n"]
foreach {Av Ap} $LesAvAp {
file rename $Av $Ap
}
return $Retour
}
proc IlpTree {{Qui ""} {Quoi ""} {Fichier ""}} {
global IlpTree
if {$Fichier==""} { set Fichier "[HomeRipp]/rules.txt"}
regsub "\.txt$" $Fichier "" FichierTsv
append FichierTsv ".tsv"
if {[info exists IlpTree($Qui,$Quoi)]} { return $IlpTree($Qui,$Quoi) }
if {[info exists IlpTree("EstCharge")]} { return "" }
set IlpTree("EstCharge") 1
set LesHeaders {}
set Min 999.
foreach Ligne [LesLignesDuFichier $Fichier] {
regsub -all "\t\t" $Ligne "\t" Ligne
set LesMots [split $Ligne "\t"]
if {$LesHeaders=={}} {
set LesHeaders [lrange $LesMots 1 end-1]
continue
}
set KL [lindex $LesMots 0]
set LesValeurs [lrange $LesMots 1 end-1]
foreach V $LesValeurs KC $LesHeaders {
# Espionne "kl=$KL= kc=$KC= $V"
if {$V=="N"} { set V 0.0 }
if {$V==""} {continue; set V $IlpTree($KC,$KL) }
set D [expr 1. - $V]
if {$D!=0.0} { set Min [Mini $Min $D] }
set IlpTree($KL,$KC) $D
}
}
set IlpTree(ListOf,Headers) $LesHeaders
set LesLignes {}
lappend LesLignes [join $LesHeaders "\t"]
foreach KL $LesHeaders {
set LaLigne {}
foreach KC $LesHeaders {
if { ! [info exists IlpTree($KL,$KC)]} { set IlpTree($KL,$KC) $IlpTree($KC,$KL) }
set D $IlpTree($KL,$KC)
# if {$D!=0.0} { set D [expr $D - $Min*0.8]}
lappend LaLigne [format "%5.3f" $D]
}
lappend LesLignes [join $LaLigne "\t"]
}
if {$Qui=="GetTreeFile" || $Qui=="GetTsv"} {
set TsvFile [SauveLesLignes $LesLignes dans $FichierTsv]
if {$Qui=="GetTsv"} {return $TsvFile }
set PhFile [ImAnnoTissueTree $TsvFile]
return $PhFile
}
return [IlpTree $Qui $Quoi]
}
proc ImAnnoTissueTree {{MatrixFile ""}} {
package require fastme
if {$MatrixFile==""} { set MatrixFile "[HomeRipp]/GenoretWww/ImAnno/ImAnnoEar/CorrelationMatrix.tsv" }
set PhFile $MatrixFile
regsub {\.tsv} $PhFile "" PhFile
append PhFile ".ph"
set LesLignes [LesLignesDuFichier $MatrixFile]
set LesDistances {}
foreach Ligne $LesLignes {
if { ! [info exists LesNoms]} {
regsub -all {\-} $Ligne " " Ligne
set LesNoms [split $Ligne "\t"]
continue
}
LConcat LesDistances [split $Ligne "\t"]
}
Espionne [llength $LesNoms]
Espionne [llength $LesDistances]
set Ph [fastme $LesNoms $LesDistances]
return [Sauve $Ph dans $PhFile]
}
proc ImAnnoImage {} {
set Image [ContenuDuFichier "http://zoom.gwdg.de/?fif=038/EG00002617_00007B.fpx&obj=iip,1.0&wid=501&hei=802&rgn=0.3125,0.3125,0.12500000,0.12500000&lng=en_US&vtrx=1&cvt=jpeg"]
return [Sauve $Image dans "[HomeRipp]/ImAnnoImage.jpg"]
}
proc VariantSCR3 {} {
foreach Fichier [lsort [glob "[RepertoireDuGenome]/atelier/SRC3/src1v*.tfa"]] {
regsub ".tfa$" $Fichier "-Prot.tfa" FiPro
set Entete [EnteteDuFichierTFA $Fichier]
set Seq [QueLaSequenceDuFichierTFA $Fichier]
set Pro [SeqNucToSeqPro $Seq]
set ProtTfa [SequenceFormatTFA $Pro $Entete "protbrut"]
Sauve $ProtTfa dans $FiPro
}
}
proc Sophie {} {
set Racine "/genomics/link/Sophie/"
catch {set Tifs [exec find $Racine -name "*.tif" -print]}
set LesTif [split $Tifs "\n"]
set LesTif [lsort $LesTif]
foreach Tif $LesTif {
if { ! [regexp -nocase ".tif$" $Tif]} { continue }
# Espionne $Tif
set Dir [file dirname $Tif]
lappend LesDir $Dir
lappend LesTifDuDir($Dir) $Tif
}
set LesDir [lsort -unique $LesDir]
EspionneL $LesDir
foreach Dir $LesDir {
Espionne $Dir
set LesIDuDir {}
set DirJpg "$Dir/jpegs"
if {[FileAbsent $DirJpg]} { file mkdir $DirJpg }
cd $DirJpg
foreach Tif [lsort $LesTifDuDir($Dir)] {
set Queue [file tail $Tif]
regsub -nocase ".tif$" $Queue ".jpg" QueueJpg
set Jpg "$DirJpg/$QueueJpg"
if {[FileAbsent $Jpg]} {
exec convert $Tif $Jpg
}
set I ""
if {[regexp -- "\-OD\-" $Jpg Oeil]} { set I [IntegerApres "-OD-" dans $QueueJpg] }
if {[regexp -- "\-OG\-" $Jpg Oeil]} { set I [IntegerApres "-OG-" dans $QueueJpg] }
if {$I==""} { continue }
lappend LesIDuDir $I
set So($Dir,$Oeil,$I) $Jpg
}
set LesImages {}
set LesIDuDir [lsort -unique -integer $LesIDuDir]
set M [expr ([llength $LesIDuDir]+1)/2]
set LesU [lrange $LesIDuDir 0 [expr $M-1]]
set LesD [lrange $LesIDuDir $M end]
lappend LesU ""
lappend LesD ""
set LesIEnDeuxColonnes {}
foreach U $LesU D $LesD {
if {$U==""} { break }
lappend LesIEnDeuxColonnes $U
if {$D==""} { break }
lappend LesIEnDeuxColonnes $D
}
foreach I $LesIEnDeuxColonnes {
set FD "$So($Dir,-OD-,$I)"
if {[FileAbsent $FD]} { set FD "null" }
lappend LesImages $FD
set FG "$So($Dir,-OG-,$I)"
if {[FileAbsent $FG]} { set FG "null" }
lappend LesImages $FG
Espionne "$I $FD $FG"
}
set Commande "montage -size 140x104 "
foreach Image $LesImages {
set QueueJpg [file tail $Image]
set Titre $QueueJpg
regsub -nocase "\.jpg" $Titre "" Titre
if {[regexp {[EP][0-9]+\.[0-9]+} $Titre Match]} {
regsub "$Match.*" $Titre "" Debut
regsub ".*$Match\-?" $Titre "" Fin
}
append Commande " -label $Debut-$Match\\n$Fin $QueueJpg"
}
set Title $Dir
regsub $Racine $Title "" Title
set Slash [string first "/" $Title 20]
if {$Slash>-1} {
set Title "[string range $Title 0 $Slash]\\n[string range $Title [incr Slash] end]"
}
append Commande " -geometry +5+5 -tile 4x -frame 5 -title $Title photo_index.html"
eval exec $Commande
}
}
proc Ya {} {
set PN [LesLignesDuFichier "[HomeRipp]/pHMGWA.txt"]
set P [lindex $PN 0]
set N [lindex $PN 4]
set Fin [string first " K D A Q T " $P]
incr Fin 15
set N [string range $N 113 $Fin]
set P [string range $P 112 $Fin]
while 1 {
set NN [string range $N 0 59]
set PP [string range $P 0 59]
Espionne $NN
Espionne $PP
Espionne
set N [string range $N 60 end]
set P [string range $P 60 end]
if {$N==""} { break }
}
exit
}
proc VerifieLesPPCR {} {
set LesPerdus {}
foreach Nom [ListeDesPABs] {
foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "notes"]] {
if { ! [regexp {^N[0-9]{4} } $Ligne N]} { continue }
set N [string trim $N]
lappend PGS($N) $Nom
if {[file exists "[RepertoireDuGenome]/ppcr_virtuels/$N"]} { continue }
lappend LesPerdus $Ligne
set Perdu($N) 1
}
}
set LesPerdus [lsort $LesPerdus]
AfficheVariable [join $LesPerdus "\n"] "" "Les N manquant"
set LesN {}
foreach FN [lsort [glob -nocomplain "[RepertoireDuGenome]/ppcr_virtuels/N*"]] {
set N [file tail $FN]
set Old($N) [ContenuDuFichier $FN]
set EOld [lindex [split $Old($N) "\n"] 0]
regsub ">$N " $EOld "" EOld
set Old($EOld) $N
regsub ">$N " $Old($N) "" ESOld($EOld)
lappend LesN $N
lappend LesE $EOld
}
set LesN [lsort -unique $LesN]
set LesLouches {}
foreach N $LesN {
Espionne $N
set P [info exists Perdu($N)]
set G [info exists PGS($N)]
if {[info exists Old($N)]} { set VO $Old($N) } else { set VO "no Old" }
if { ! $P && $G } { continue }
set T "$N $P $G"
if {$G} { lappend T $PGS($N) }
if {$VO=="no Old"} { lappend T $VO }
lappend LesLouches [join $T " "]
}
AfficheVariable [join $LesLouches "\n"] "" "Les N louches"
}
proc Utf8 {} {
set Texte [ContenuDuFichier "[HomeRipp]/GenoretWww/Library/Ligatures.txt"]
set Texte [ContenuDuFichier "[HomeRipp]/GenoretWww/phpNE/Article/pdf_txt/UpL20070206173536_of_calpain.pdf.txt"]
return $Texte
Espionne $Texte
regsub {\uFB01} $Texte "fi" Texte
Espionne "\uFB01"
Espionne $Texte
return $Texte
}
proc JavOO {{What ""} {Query ""} {Resource ""} {IP ""} {Port ""} {User ""} {Password ""}} {
if {$What==""} { set What "Data" }
# if {$Query==""} { set Query "select \"Nom des participants\" from LiLaboDef order by \"Nom des participants\";" }
# if {$Resource==""} { set Resource "ListeLabo" }
if {$Query==""} { set Query "select * from GUCY2D;" }
if {$Resource==""} { set Resource "LCA_GUCY2D" }
if {$IP==""} { set IP "olo" }
if {$Port==""} { set Port 18000 }
set CanalJavOO [socket $IP $Port]
puts $CanalJavOO "<request>"
puts $CanalJavOO "<clientID>123</clientID>"
puts $CanalJavOO "<resource>$Resource</resource>"
puts $CanalJavOO "<sql>$Query</sql>"
puts $CanalJavOO "</request>"
puts $CanalJavOO "<!-- END -->"
flush $CanalJavOO
Espionne $Query
set LaReponse {}
while {[gets $CanalJavOO Ligne]>=0} {
if {[regexp "<!-- END -->" $Ligne]} { break }
lappend LaReponse $Ligne
}
set Reponse [join $LaReponse "\n"]
if {$What=="Data" || $What=="DataHtml"} { set Reponse [ValeurDeLaBalise "data" Reponse "NePasRogner"] }
if {$What=="DataHtml"} { set Reponse "<pre>$Reponse</pre>" }
return $Reponse
}
proc CafeDeCafe {} {
return [QuestionDeScience ouragan::GGWmm "ret ListeDesPABs"]
}
proc CompteGenoret {} {
set Total 0
foreach Fichier [GlobRecursif "*.php" /home/berthomg/wwwGB/genoret] {
set N 0
scan [exec wc -l $Fichier] "%d" N
incr Total $N
}
Espionne $Total
exit
}
proc BLAT_clientPourTousRR {{DirIn ""} {DirOut ""} {DirOuGenome ""} {Outstyle ""} {Host ""} {Port ""} {OptionSup ""} {ListeATraiter ""}} {
Wup "If DirIn has no / we use RepretoireDuGenome/DirIn"
Wup "If DirOut has no / we use RepretoireDuGenome/DirOut"
Wup "BLAT program is BLAST Like Alignment Tool"
Wup "It is optimised to align mRNA or DNA fragment onto genomes"
Wup "BLAT can be run in Server way with complete database indexes loaded in memory."
Wup "gfServer permits to load and start a server."
Wup "gfClient permits to submit sequences to the server."
Wup "Output '''[[Known Bugs]]''' can be set to looks like blast output"
#DirIn directory where to find queries tfa files
#DirOut directory where to store results
if {$DirIn=="" && $DirOut==""} {
Espionne "BLAT_clientPourTous Usage is: DirIn \[Input complete dir path\] DirOut \[same for output\] Organism \[human mouse\] (optional Outstyle \[blast\] Host \[star6\] Port \[linked to Organism\])"
return ""
}
if { ! [regexp "/" $DirIn]} { set DirIn "[RepertoireDuGenome]/$DirIn" }
if {! [file exists $DirIn]} {
Espionne "Problem input directory doesn't not exists."
return ""
}
if { ! [regexp "/" $DirOut]} { set DirOut "[RepertoireDuGenome]/$DirOut" }
if {![file exists $DirOut]} { file mkdir $DirOut }
if {$Port ==""} {set Port [BLATGenomePort $DirOuGenome]}
if {$Host ==""} {set Host [BLATServerName]}
if {$Outstyle==""} {set Outstyle "blast"}
if {[regexp -nocase "blast" $Outstyle]} {
set Outstyle [string tolower $Outstyle]
}
if {$ListeATraiter=="ListeDesPABs"} { set ListeATraiter [ListeDesPABs] }
if {$ListeATraiter == ""} {
set ListeATraiter [glob -nocomplain -directory $DirIn -tails "*"]
}
if {! [BLAT_server_Running $DirOuGenome]} {
Espionne "BLAT Server for $DirOuGenome is not running."
#Espionne "Trying to launch it."
#BLAT_server Start $DirOuGenome $Host $Port
return ""
}
set I 9999
foreach PAB $ListeATraiter {
set Input "$DirIn/$PAB"
set Output "$DirOut/$PAB"
if {[file exists $Output]} {continue}
if {[incr I]>100} {
Espionne "I'll run BLAT $Input $Output $DirOuGenome $Outstyle"
set I 0
}
BLAT_client $Input $Output $DirOuGenome $Outstyle $Host $Port $OptionSup
}
return ""
}
proc TrieLesTissuesDesSelectedEST {{Fichier ""} {Quoi ""}} {
if {$Quoi==""} { set Quoi "Choose" }
if {$Fichier==""} { set Fichier "[Fiches]/SelectedEST" }
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase "TissueType" $Ligne]} { continue }
set T [StringSuivant "TissueType" dans $Ligne]
set T [string trim $T " \t"]
lappend LesTs $T
}
set LesTs [lsort -unique $LesTs]
set LesBonsT {}
foreach T $LesTs {
lappend LesBonsT $T
}
# set LesBonsT [lsort -unique $LesBonsT]
if {$Quoi=="GetList"} { return $LesBonsT }
return [MorceauxChoisis $LesBonsT]
}
proc TrieLesTimesDesDevStage {{Fichier ""}} {
if {$Fichier==""} { set Fichier "[Fiches]/SelectedEST" }
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase "DevStage" $Ligne]} { continue }
set T [StringSuivant "DevStage" dans $Ligne]
set T [string trim $T " \t"]
lappend LesTs $T
}
set LesTs [lsort -unique $LesTs]
set LesBonsT {}
foreach T $LesTs {
set OldT $T
set T [string tolower $T]
if {$T=="adult"} { set T "7 week" }
regsub "adult" $T "" T
regsub -all {approx\.|age|old|\~} $T "" T
regsub {e18\-p} $T {p0-p} T
regsub "whole embryo including extraembryonic tissues at " $T "" T
regsub {days? *pc} $T "day post coitum" T
regsub " pc embryo" $T "day post coitum" T
regsub "postcoitum" $T "post coitum" T
regsub "d\.p\.c" $T "dpc" T
regsub "p\.c" $T "dpc" T
regsub "embryonic" $T "embryo" T
regsub "cells" $T "cell" T
regsub "one\-cell" $T "1 cell" T
regsub "two\-cell" $T "2 cell" T
regsub "four\-cell" $T "4 cell" T
regsub "eight\-cell" $T "8 cell" T
regsub "eigth\-cell" $T "8 cell" T
regsub "sixteen\-cell" $T "16 cell" T
regsub "cell\-.*" $T "cell" T
regsub -all "days" $T "day" T
if {[regexp "cell" $T]} { regsub {embryo[a-z]*} $T "" T }
if {[regexp {embryo[a-z]*[0-9\.\- ]+dpc} $T]} { regsub {embryo[a-z]*} $T "" T }
regsub "dpc" $T "day post coitum" T
regsub {embryos?} $T "day post coitum" T
set T [join [LesMotsDeLaLigne $T] " "]
regsub -all "day day" $T "day" T
regsub -all "day day" $T "day" T
set T [join [LesMotsDeLaLigne $T] " "]
regsub -all {day post coitum +day post coitum} $T "day post coitum" T
regsub {day post coitum[^0-9]+} $T "day post coitum " T
regsub {([0-9])\-([a-z])} $T {\1 \2} T
regsub -all {([0-9])([a-z])} $T {\1 \2} T
set T [join [LesMotsDeLaLigne $T] " "]
if {[regexp "day post coitum" $T]} {
regsub "day post coitum" $T "" T
set T "daypostcoitum $T"
} elseif {[regexp {weeks?|months?|years?|days?} $T Match]} {
regsub $Match $T "" T
set T [string trim $T " -"]
regsub "s$" $Match "" Match
set T "postnatal$Match $T"
} elseif {[regexp {cell} $T]} {
regsub "cell" $T "" T
set T [string trim $T " -"]
set T "cell $T"
} elseif {[regexp {^[0-9\. ]+$} $T]} {
set T [string trim $T " -"]
set T "daypostcoitum $T"
} elseif {[regexp {^e[0-9\. ]+$} $T]} {
set T [string trim $T " -"]
regsub "e" $T "" T
set T "daypostcoitum $T"
} elseif {[regexp {^p[0-9]+[ \-]p[0-9]+$} $T]} {
regsub -all "p" $T "" T
set T "postnatalday $T"
} elseif {[regexp {^p[0-9]+$} $T]} {
regsub -all "p" $T "" T
set T "postnatalday $T"
}
# regsub -all {[0-9][0-9\.\- ]*[0-9]} $T "XXX" T
lappend LesBonsT "$T = $OldT"
}
set LesBonsT [lsort -unique $LesBonsT]
return [AfficheVariable [join $LesBonsT "\n"]]
}
proc MapAreaFromCanva {TexteOuFichierTcl FichierImage FichierHtml} {
if {[regexp "\n" $TexteOuFichierTcl]} {
set TexteTcl $TexteOuFichierTcl
} else {
set TexteTcl [ContenuDuFichier $TexteOuFichierTcl]
}
set Map "map"
lappend LeHtml [ContenuDuFichier "[GscopeEtc]/EnteteHtmlPourIllustreLesChromosomes.html"]
lappend LeHtml "<IMG src=$FichierImage alt='Chromosome' usemap=#$Map>"
lappend LeHtml "<MAP name=$Map>"
foreach Ligne [split $TexteTcl "\n"] {
if { ! [regexp {^create (rectangle|oval) } $Ligne]} { continue }
ScanLaListe $Ligne C R XMin YMin XMax YMax
set Coo "$XMin,$YMin,$XMax,$YMax"
regsub -all {\.[0-9]+} $Coo "" Coo
set Tags [StringSuivant "-tags " dans $Ligne]
regsub -- { \-width.*} $Tags "" Tags
if {[regexp "Cadre$" $Tags]} { continue }
regsub {^\{} $Tags "" Tags
regsub {\}$} $Tags "" Tags
scan $Tags "%s" Nom
if {[EstUnPAB $Nom]} {
set Url "[WscopeScience]&FileMoi&$Nom"
set Texte "$Tags Do I show the gene $Nom with Wscope"
lappend LeHtml "<AREA href='#' onclick=\"javascript:DoIOpen('$Url','$Texte');\" shape='rect' coords=$Coo alt='$Tags' title='$Tags'>"
} else {
lappend LeHtml "<AREA href='javascript:alert(\"$Tags\");' shape='rect' coords=$Coo alt='$Tags' title='$Tags'>"
}
}
return [SauveLesLignes $LeHtml dans $FichierHtml]
}
proc VersionSurBiolo {{Rep ""}} {
foreach Dec [lsort [glob "/dec/biolo/$Rep/*.tcl"]] {
regsub "/dec/" $Dec "/linux/" Lin
if {[FileAbsent $Lin]} {
Espionne "absence de $Lin"
continue
}
if {[ContenuDuFichier $Dec]==[ContenuDuFichier $Lin]} { continue }
exec dxdiff $Dec $Lin
}
exit
}
proc TestRavi {} {
package require tdom
set MacsimXml [ContenuDuFichier "ra.xml"]
set NoeudMacsim [[dom parse $MacsimXml] documentElement]
Espionne $NoeudMacsim
}
proc VerifieInfos {} {
foreach Nom [ListeDesPABs] {
set Texte [ExtraitInfo $Nom]
set LeBeau {}
foreach Ligne [split $Texte "\n"] {
if {[string trim $Ligne]==""} { Espionne "$Nom avec ligne vide" ; continue}
scan $Ligne "%s" Clef
if { ! [regexp -nocase {^[0-9a-z\-_]+\:$} $Clef]} {
continue
set Prems [string first $Ligne $Texte]
set Deuss [string first $Ligne $Texte [expr $Prems + 1]]
if {$Deuss<0} { Informe $Nom } else { Espionne "$Nom $Ligne" }
}
lappend LeBeau $Ligne
}
Espionne [SauveLesLignes $LeBeau dans [GscopeFile $Nom "infos2"]]
}
}
proc FindOligosForSerena {} {
foreach Ligne [LesLignesDuFichier [RepertoireDuGenome]/AllStopOligosForSerena.txt] {
scan $Ligne "%s" P
set IGBMC [StringApres ">" dans [ContenuDuFichier [RepertoireDuGenome]/blastnoligo20060518/$P]]
Espionne "$IGBMC [Oli $P Description]"
}
exit
}
proc HistoJulie {} {
foreach Ligne [LesLignesDuFichier /genomics/link/Balibase30/all.seqcount] {
scan $Ligne "%d" X
lappend LesX $X
}
Histogramme $LesX Nombre
}
proc CorrigeCAPweb {} {
foreach F [LesLignesDuFichier "[HomeRipp]/CAPwebFichiersAModifier.txt"] {
Espionne $F
set V [lindex [glob -nocomplain "$F.2006*"] 0]
set Texte [ContenuDuFichier $V]
if { ! [regexp {^<\?} $Texte]} { continue }
# Garde $F
regsub {^<\?} $Texte "<?php\nsession_start();\n//rR sur conseil de Guillaume Berthommier rR//\n" Texte
Espionne $Texte
Sauve $Texte dans $F
}
exit
}
proc PABDevantEnAccess {} {
foreach Nom [ListeDesPABs] {
foreach Rep [list nuctfa prottfa] {
set Fic [GscopeFile $Nom $Rep]
if {[FileAbsent $Fic]} { FaireLire "$Fic absent" ; continue }
set Texte [ContenuDuFichier $Fic]
if {[regexp "^>$Nom " $Texte]} { continue }
scan $Texte "%s" Access
regsub ">" $Access "" Access
regsub -all {\-} $Access "\\-" AccessR
Espionne $Access
regsub ">$AccessR " $Texte ">$Nom $Access " Texte
regsub "$AccessR $AccessR " $Texte "$Access " Texte
regsub "Musmusculus" $Texte "Mus musculus" Texte
regsub -all " " $Texte " " Texte
Espionne "$Rep/$Nom [lindex [split $Texte "\n"] 0]"
#rR Sauve $Texte dans $Fic
}
}
}
proc MemeSequence {} {
foreach Nom [ListeDesPABs] {
set S [string toupper [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]]
if {[info exists NomsDe($S)]} {
set D [lindex $NomsDe($S) end]
set mAC [ExtraitInfo $Nom "AccessRefseq:"]
set mGN [ExtraitInfo $Nom "ValiGN:"]
set tAC [ExtraitInfo $D "AccessRefseq:"]
set tGN [ExtraitInfo $D "ValiGN:"]
set Message ""
if {$mAC!=$tAC} { append Message " $mAC $tAC" }
if {$mGN!=$tGN} { append Message " $mGN $tGN" }
Espionne "Deja vu $D=$Nom $mAC [format %-10s $mGN] $Message"
}
lappend NomsDe($S) $Nom
}
exit
}
proc VerifMiRNAdeMarianna {} {
foreach Nom [ListeDesPABs] {
set AccessRefseq [ExtraitInfo $Nom "AccessRefseq:"]
lappend NomsDe($AccessRefseq) $Nom
}
foreach Ligne [LesLignesDuFichier "/genomics/link/MiRNAkarali/DeMarianna/unique.lst"] {
scan $Ligne "%s" Access
if {[info exists NomsDe($Access)]} { continue }
set LE [LaSequenceDesBanques $Access]
Espionne $Access
EspionneL $LE
}
exit
}
proc BelleBanque {} {
set FichierTFA "[RepertoireDuGenome]/banques/protenplus"
set S 0
set C 0
set B 0
foreach Access [LaSequenceDuTFAs $FichierTFA "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $FichierTFA $Access]
set Entete [EnteteDuTexteTFA $TFA]
Espionne "$Access"
if {[regexp "^s" $Access]} { set A "SCB:Spur[format %3.3d [incr S]] $Entete" }
if {[regexp "^c" $Access]} { set A "SCB:Cint[format %3.3d [incr C]] $Entete" }
if {[regexp "^A" $Access]} { set A "SCB:$Access $Entete" }
set Seq [QueLaSequenceDuTexteTFA $TFA]
set New [SequenceFormatTFA $Seq $A "protbrut"]
lappend LaNouvelle $New
}
set Nouvelle [join $LaNouvelle "\n"]
return [Sauve $Nouvelle dans "$FichierTFA.bellebanque"]
}
proc LocaliseSurADN {{Sequence ""} {Quoi ""}} {
while {$Sequence==""} {
FaireLire "Please enter the dna sequence to search"
set Sequence [Entre]
if {$Sequence=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
}
if {$Quoi==""} { set Quoi "FR" }
set OLS [expr [string length $Sequence] -1]
global ADN TDN RAC
if { ! [info exists ADN]} { ChargeADNetTDNetRAC }
set I 0
set LesHitsF {}
while {[set Indices [string first $Sequence $ADN $I]]>-1} {
append Indices " [expr $Indices+$OLS]"
scan $Indices "%d %d" D F
set I [expr $D+1]
lappend LesHitsF "$Indices F"
if {$Quoi=="First" || $Quoi=="FFirst"} { break }
}
if {$Quoi=="F" || $Quoi=="First" || $Quoi=="FFirst"} { return $LesHitsF }
set L [string length $RAC]
set I 0
set Reverse [NucToReverseAndComplementNuc $Sequence]
set LesHitsR {}
while {[set Indices [string first $Sequence $RAC $I]]>-1} {
append Indices " [expr $Indices+$OLS]"
scan $Indices "%d %d" D F
set I $F
lappend LesHitsR "[expr $L-$F+1] [expr $L-$D+1] R"
if {$Quoi=="First" || $Quoi=="RFirst"} { break }
}
if {$Quoi=="R" || $Quoi=="First" || $Quoi=="RFirst"} { return $LesHitsR }
return [concat $LesHitsF $LesHitsR]
}
proc StopDuMs {} {
foreach Nom [ListeDesPABs] {
set S [Box $Nom orient]
set F [Box $Nom fin]
if {$S=="R"} { continue }
set Stop [BoutADN [incr F 1] [incr F 2] $S]
Espionne "$Nom $Stop"
}
exit
}
proc EssaiTcl {} {
puts $::RepertoireDuGenome
exit
}
proc CreateGscopeDatabaseForCDSProtFoF {} {
while 1 {
set FoF [ButineArborescence All "[RepertoireDuGenome]"]
if {$FoF=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
break
}
foreach Ligne [LesLignesDuFichier $FoF] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s" FN
if { ! [file exists $FN]} { continue }
set Access [EnteteDuFichierTFA $FN "Access"]
lappend LesFOFs "$Access $FN"
}
set StartFOF "[RepertoireDuGenome]/StartingWithNuc.fof"
if {[FileAbsent $StartFOF]} {
set StartFOF [SauveLesLignes $LesFOFs dans $StartFOF]
}
CreeBornesDesPABsPourUneCollection $StartFOF
}
proc AddAliasPourMiRNA {} {
foreach F [LesLignesDuFichier /genomics/link/MiRNA/ExtractFromRefseqAllMiRNA2907.fof] {
set Access [file tail $F]
regsub ".nuctfa" $Access "" Access
scan [PremiereLigneDuFichier $F] "%s" Alias
regsub ">" $Alias "" Alias
set N "$Alias $F"
Espionne $N
lappend LesN $N
}
SauveLesLignes $LesN dans /genomics/link/MiRNA/ExtractFromRefseqAllMiRNA2907.fofnew
exit
}
proc VerifieExtractRefseqOldAndNew {} {
foreach N [lsort [glob [RepertoireDuGenome]/sequencesAllMiRNA2907/*.prottfa]] {
set Q [file tail $N]
set O [RepertoireDuGenome]/sequences/$Q
set SN [QueLaSequenceDuFichierTFA $N]
set SO [QueLaSequenceDuFichierTFA $O]
if {$SN!=$SO} {
FaireLire "$N\n$SN\n$SO"
}
}
}
proc VerifieNucProt {} {
foreach FN [lsort [glob *.nuctfa]] {
Espionne $FN
set N [QueLaSequenceDuFichierTFA $FN]
regsub ".nuctfa$" $FN "" FP
append FP ".prottfa"
set P [QueLaSequenceDuFichierTFA $FP]
set PduN [SeqNucToSeqPro $N]
if {$PduN!=$P} {
Espionne "$PduN\n$P"
FaireLire $FN
}
}
}
proc CopieEnteteDuNuctfaVersProttfaPourTous {} {
foreach Nom [ListeDesPABs] {
Espionne [CopieEnteteDuNuctfaVersProttfa $Nom]
}
}
proc CopieEnteteDuNuctfaVersProttfa Nom {
set BonneEntete [EnteteDuFichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"]
set Fichier "[RepertoireDuGenome]/prottfa/$Nom"
set LesLignes [LesLignesDuFichier $Fichier]
set LaSeq [lrange $LesLignes 1 end]
SauveLesLignes [concat [list $BonneEntete] $LaSeq] dans "[RepertoireDuGenome]/prottfaNew/$Nom"
return $BonneEntete
}
proc AccessDuMiRNAPourTous {} {
foreach Nom [ListeDesPABs] {
Espionne [AccessDuMiRNA $Nom]
}
}
proc AccessDuMiRNA Nom {
set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
set LesLignes [LesLignesDuFichier $Fichier]
set Entete [lindex $LesLignes 0]
set LesMots [split $Entete " "]
set GN [lindex $LesMots 1]
set DE [join [lrange $LesMots 2 end] " "]
set Access [lindex $LesMots end]
set BonDE [ExtractFromRefseq $Access AllMiRNA2907 [RepertoireDuGenome] GetDefinition]
set GeneName $GN
if { ! [regexp {\-V[0-9]+$} $GeneName] && [regexp {transcript variant ([0-9]+)} $BonDE Match V]} {
append GeneName "-V$V"
}
append BonDE " from $Access"
set BonneEntete ">$Nom $GeneName $BonDE"
set LaSeq [lrange $LesLignes 1 end]
SauveLesLignes [concat [list $BonneEntete] $LaSeq] dans "[RepertoireDuGenome]/nuctfaNew/$Nom"
InformeSansDemander $Nom "ValiDE: $BonDE"
InformeSansDemander $Nom "AccessRefseq: $Access"
return $BonneEntete
}
proc ExtractFromRefseqPourTous Fichier {
set Repertoire "/genomics/link/MiRNA"
set Racine [file tail $Fichier]
regsub {\.lst} $Racine "" Racine
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" Access
Espionne "I'll extract $Access"
set Status [ExtractFromRefseq $Access $Racine $Repertoire]
Espionne $Status
}
}
proc ExtractFromRefseq {Access Racine Repertoire {Action ""}} {
set FichierLog "$Repertoire/ExtractFromRefseq$Racine.log"
set FichierFof "$Repertoire/ExtractFromRefseq$Racine.fof"
set RepSeq "$Repertoire/sequences$Racine"
if {[FileAbsent $RepSeq]} {file mkdir $RepSeq}
set FichierNuc "$RepSeq/$Access.nuctfa"
if {$Action!="GetDefinition" && [file exists $FichierNuc]} { return "$Access already extracted" }
set Texte [Getz $Access refseq]
if {$Texte==""} {
set Message "$Access was not found"
AppendAuFichier $FichierLog $Message
return $Message
}
set F "NoCDSFound"
set GN "NotFound"
set OS "UnknownOS"
set LaDE {}
set DansDef 0
foreach Ligne [split $Texte "\n"] {
if {$DansDef} {
if {[regexp {^ +} $Ligne]} {
set DE [string trim $Ligne]
lappend LaDE $DE
continue
}
set DansDef 0
}
if {[regexp " CDS" $Ligne]} {
if {$F!="NoCDSFound"} { continue }
regsub -all {[^0-9]} $Ligne " " Limites
scan $Limites "%d %d" D F
continue
}
if {[regexp "/gene=" $Ligne]} {
if {$GN!="NotFound"} { continue }
set GN [StringApres "/gene=" dans $Ligne]
regsub -all {\"} $GN "" GN
continue
}
if {[regexp {^DEFINITION} $Ligne]} {
set DansDef 1
set DE [StringSuivant "DEFINITION" dans $Ligne]
lappend LaDE $DE
continue
}
if {[regexp {^ *ORGANISM} $Ligne]} {
if {$OS!="UnknownOS"} { continue }
set OS [StringSuivant "ORGANISM" dans $Ligne]
set OS [string trim $OS]
continue
}
}
if {$F=="NoCDSFound"} {
set Message "$Access no CDS found"
AppendAuFichier $FichierLog $Message
return $Message
}
if {$GN=="NootFound"} { set GN $Access }
set DE [string trim [join $LaDE " "]]
if {$Action=="GetDefinition"} { return $DE }
exit
set NucSeqTotale [QueLaSequenceADNDuTexteGenbank $Texte]
set DernierCodon [string range "n$NucSeqTotale" [expr $F-2] $F]]
if {[CodonStopPossible $DernierCodon]} { incr F -3 }
set NucSeq [string range "n$NucSeqTotale" $D $F]
set ProSeq [SeqNucToSeqPro $NucSeq]
set GeneName $GN
if {[regexp {transcript variant ([0-9]+)} $DE Match V]} {
append GeneName "-V$V"
}
set OSDE "$OS $DE"
if {[regexp "^$OS" $DE]} { set OSDE $DE }
set Header "$GeneName $OSDE from $Access"
set N [SequenceFormatTFA $NucSeq $Header nucbrut]
set P [SequenceFormatTFA $ProSeq $Header protbrut]
regsub ".nuctfa$" $FichierNuc "" FichierPro
append FichierPro ".prottfa"
set FichierProOk [Sauve $P dans $FichierPro]
set FichierNucOk [Sauve $N dans $FichierNuc]
AppendAuFichier $FichierFof $FichierNucOk
return "$GeneName $FichierNucOk"
}
proc SontCeLesMemes {} {
set f [open /genomics/link/Ms/beton/adn "r"]
gets $f Manu
set f [open /genomics/link/MsTigrManu/beton/adn "r"]
gets $f Tigr
set GrosTigr "$Tigr[string range $Tigr 1 end]"
set Mama [string range $Manu 1 end]
set Titi [string range $GrosTigr 1070522 end]
foreach Ligne [LesLignesDuFichier "/genomics/link/MsTigrManu/fiches/bornesdespabs"] {
scan $Ligne "%s %s %s %s" MST DebT FinT SensT
set AdnT [string range $Tigr $DebT $FinT]
set DebM [expr $DebT - 1070521]
set FinM [expr $FinT - 1070521]
if {$DebM<0} { continue }
set AdnM [string range $Manu $DebM $FinM]
if {$AdnT==$AdnM} { continue }
Espionne "$Ligne\n[string range $AdnT 0 end]\n[string range $AdnM 0 end]"
set i 0
foreach T [split $AdnT ""] M [split $AdnM ""] {
incr i
if {$T==$M} { continue }
Espionne "$i $T $M"
}
}
exit
foreach Ligne [LesLignesDuFichier "/genomics/link/Ms/fiches/bornesdespabs"] {
scan $Ligne "%s %s %s %s" MSM DebM FinM SensM
set AdnM [string range $Manu $DebM $FinM]
set DebT [expr $DebM + 1070521]
set FinT [expr $FinM + 1070521]
set AdnT [string range $GrosTigr $DebT $FinT]
if {$AdnM==$AdnT} { continue }
Espionne "$Ligne\n[string range $AdnM 0 end]\n[string range $AdnT 0 end]"
set i 0
foreach M [split $AdnM ""] T [split $AdnT ""] {
incr i
if {$M==$T} { continue }
Espionne "$i $M $T"
}
}
}
proc FinsFlo {} {
foreach F [glob "sc*gene.tfa"] {
set Seq [QueLaSequenceDuFichierTFA $F]
set Fin [string range $Seq end-53 end]
set RAC [NucToReverseAndComplementNuc $Fin]
set Nom [string range $F 2 5]
Espionne "$Nom $Fin $RAC"
}
exit
}
proc LoadTxlForMonika {} {
set RepDeMonika "/genomics/link/Monika/DeMonika"
set Fichier "$RepDeMonika/FINAL_LIST.txt"
set Queue [file tail $Fichier]
regsub {\.[a-z]+$} $Queue "" Queue
LoadTxl $Fichier T "" "" "CoLi"
set LesTetes $T(ListHeaderPlease,$Queue)
foreach I $T(ListAllPlease,$Queue) {
set A $T(Product_Id,$I)
Espionne "$I $A"
set LignesEMBL [LaSequenceDesBanques $A]
EspionneL $LignesEMBL
SauveLesLignes $LignesEMBL dans "$RepDeMonika/$I.embl"
}
exit
}
proc LesFastas {{User ""}} {
set MesProjets [LesProjetsDe "$User"]
foreach Projet $MesProjets {
set Existe($Projet) 1
}
foreach Rep [glob /genomics/g*/*] {
if { ! [file readable $Rep]} {continue}
set MesFastas [glob -nocomplain $Rep/*.fasta]
if {$MesFastas=={}} { continue }
if {[llength $MesFastas] < 1 } { Espionne $MesFastas }
set Fasta [lindex $MesFastas 0]
set RepDuG [file tail [file dirname $Fasta]]
if {![info exists Existe($RepDuG)]} { continue }
lappend LesFastas $Fasta
}
return $LesFastas
}
proc TestHttpCopy {} {
HttpCopy "http://hgdownload.cse.ucsc.edu/goldenPath/currentGenomes" LesLignes
EspionneL $LesLignes
exit
}
proc DecortiqueDisEmbl {} {
global ItemHTMLFermant ; set ItemHTMLFermant(param) ">"
global ItemHTMLFermant ; set ItemHTMLFermant(br) ">"
set Texte [ContenuDuFichier "[HomeRipp]/vrac/DisEmblResultat.html"]
while 1 {
set Att ""
set Titre [ValeurDeLaBalise h3 Texte Rogner]
set F [ValeurDeLaBalise tt Texte Rogner Att]
if {$F==""} { break }
set F [StringSuivant "<br>" dans $F]
regsub -all {<[^>]+>} $F "" F
regsub -all -nocase {[^A-Z]} $F "" F
Espionne "$Titre"
Espionne "$F"
}
exit
set X [ValeurDeLaBalise form Texte]
Espionne $X
Espionne "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
set X [ValeurDeLaBalise form Texte]
Espionne $X
exit
}
proc ToutPourYann {} {
# set Sequence [QueLaSequenceDuFichierTFA "/genomics/link/ProGS/prottfa/PGS001"]
set Access "P10827"
set Site "http://globplot.embl.de/cgiDict.py"
set Url $Site
append Url "?key="
append Url "process"
append Url "&SP_entry="
append Url $Access
append Url "&sequence_string="
append Url ""
append Url "¶ms="
append Url "RL"
append Url "&peak_frame_dis="
append Url 5
append Url "&join_frame_dis="
append Url 4
append Url "&do_smart="
append Url "true"
append Url "&peak_frame_dom="
append Url 74
append Url "&join_frame_dom="
append Url 15
append Url "&plot_title="
append Url "titreduplot"
append Url "&smooth_frame_1="
append Url 5
append Url "&smooth_frame_2="
append Url 5
set LesLignes {}
HttpCopy $Url LesLignes
EspionneL $LesLignes
SauveLesLignes $LesLignes dans GlobPlotResultat.html
# set Sequence [QueLaSequenceDuFic
set Site "http://dis.embl.de/cgiDict.py"
set LesCVs {}
lappend LesCVs "key=process"
lappend LesCVs "SP_entry=$Access"
lappend LesCVs "sequence_string="
lappend LesCVs "smooth_frame=8"
lappend LesCVs "peak_frame=8"
lappend LesCVs "join_frame=4"
lappend LesCVs "fold_coils=1.20"
lappend LesCVs "fold_rem465=1.20"
lappend LesCVs "fold_hotloops=1.40"
lappend LesCVs "plot_title="
lappend LesCVs "doApplet=true"
lappend LesCVs "tango_PH=7.40"
lappend LesCVs "tango_T=278.15"
lappend LesCVs "tango_I=0.05"
lappend LesCVs "tango_TFE=0.00"
lappend LesCVs "fold_tango=1.00"
set CVs [join $LesCVs "&"]
set Url "$Site?$CVs"
set LesLignes {}
HttpCopy $Url LesLignes
EspionneL $LesLignes
SauveLesLignes $LesLignes dans DisEmblResultat.html
exit
}
proc Yann {} {
# set Texte [HttpGetTextFromUrl "http://saiph"]
set Texte [ContenuDuFichier "[HomeRipp]/vrac/fir.htm"]
while 1 {
set F [ValeurDeLaBalise font Texte Rogner Att]
if {$F==""} { break }
Espionne "$F $Att"
}
exit
set X [ValeurDeLaBalise form Texte]
Espionne $X
Espionne "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
set X [ValeurDeLaBalise form Texte]
Espionne $X
exit
}
proc Compress {{LesReps ""}} {
if {$LesReps==""} {
set LesPossiblesReps {}
foreach Rep [glob "[RepertoireDuGenome]/*/"] {
lappend LesPossiblesReps $Rep
}
set LesReps [MorceauxChoisis $LesPossiblesReps]
}
foreach Rep $LesReps {
if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
foreach Nom [ListeDesPABs] {
set Fichier "$Rep/$Nom"
if {[FileAbsent $Fichier]} { continue }
Espionne "I'll compress $Fichier"
exec compress $Fichier
}
}
}
proc MenageGstock {} {
set LesPath {}
LConcat LesPath [glob -nocomplain "/gstock/data*/g*/*"]
foreach Path $LesPath {
if {[regexp {lost\+found} $Path]} { continue }
if { ! [regexp {/data[0-9]/g[0-9]+/} $Path]} { continue }
if { ! [file isdirectory $Path]} { continue }
if {[file type $Path]=="lnk"} { continue }
set Owner [file attributes $Path -owner]
lappend LesPathDe($Owner) $Path
lappend LesOwner $Owner
set Queue [file tail $Path]
if {[info exists DejaVu($Queue)]} { FaireLire "DejaVu $Queue\n$DejaVu($Queue)\n$Path" }
set DejaVu($Queue) $Path
}
set LesOwner [lsort -unique $LesOwner]
set LesTodo {}
foreach Owner $LesOwner {
foreach Path $LesPathDe($Owner) {
lappend LesToDo "$Owner $Path"
}
if {[FileAbsent "/gstock/user/$Owner"]} { lappend LesMakeOwner "mkdir /gstock/user/$Owner" }
}
AfficheListe $LesMakeOwner
set ToDo [AfficheListe $LesToDo "AvecRetour"]
foreach DoIt [split $ToDo "\n"] {
scan $DoIt "%s %s" Owner Path
set Destin "/gstock/user/$Owner"
if {[FileAbsent $Destin]} { set Destin "/gstock/user/Inconnu" }
set Queue [file tail $Path]
set NewPath "$Destin/$Queue"
if {[FileExists $NewPath]} { FaireLire "$NewPath already exists. I'll skip" ; continue }
file rename $Path $NewPath
}
}
proc LesProjetsDe {{User ""} {QuoiEncore ""} {Action ""} {SansDoublon ""}} {
if {$Action==""} { set Action "Show" }
set SansDoublon [string equal -nocase $SansDoublon "SansDoublon"]
if {$QuoiEncore==""} { set QuoiEncore "Rien" }
set NbSeqTotal 0
set NbProjects 0
set OldNbSeq -1
set LesBornes [glob -nocomplain "/genomics/g*/*/fiches/bornesdespabs"]
LConcat LesBornes [glob -nocomplain "/gstock/*/fiches/bornesdespabs"]
foreach Fichier $LesBornes {
set Owner [file attributes $Fichier -owner]
if {$User!=""} {
set Ligne [exec ls -l $Fichier]
if { ! [regexp $User $Ligne]} {
if {$User!="Inconnu"} { continue }
if {$User=="Inconnu" && ! [regexp {^[0-9]+$} $Owner]} {
continue
} else {
set Owner "Inconnu"
}
}
}
set Rep [file tail [file dirname [file dirname $Fichier]]]
set NbSeq [llength [LesLignesDuFichier $Fichier]]
# Espionne "$Owner $Rep $NbSeq $Fichier"
if {$NbSeq==0} { set OldNbSeq $NbSeq ; continue }
# Espionne "$SansDoublon && $OldNbSeq==$NbSeq"
if {$SansDoublon && $OldNbSeq==$NbSeq} { continue }
set OldNbSeq $NbSeq
incr NbSeqTotal $NbSeq
incr NbProjects
set Retour [format "%-10s %-20s %s" $Owner $Rep $Fichier]
if {$QuoiEncore=="NbSeq"} {
set Retour [format "%-28s %10d %s" $Rep $NbSeq sequences]
} else {
if {$QuoiEncore!="Rien"} { append Retour [set $QuoiEncore] }
}
lappend LesProjets $Retour
}
lappend LesProjets [format "%15d %-12s %10d %s" $NbProjects projects $NbSeqTotal sequences]
if {$Action=="GetList"} { return $LesProjets }
set Clavier "Postpone"
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "Magenta"
TouchePour $Clavier "RangeGstock" "RangeGstock \[set PagePropre(@F@)\]"
TouchePour <2> "/ sel." "RangeGstock \[selection get\]"
TouchePour <3> "/DoIt" "RangeGstock \[selection get\] - Force"
set F [AfficheListe $LesProjets "" "$User Gscope_Projects"]
return $F
}
proc RangeGstock {{Projets ""} {DestinDefaut ""} {Force ""}} {
set Force [string equal -nocase $Force "Force"]
if {$DestinDefaut=="" || $DestinDefaut=="-"} { set DestinDefaut "Projets_Owner" }
set LesProjets [split $Projets "\n"]
foreach Ligne $LesProjets {
lassign [LesMotsDeLaLigne $Ligne] Owner Projet Path
if {[regexp "ProjetsManu" $Path]} { continue }
if {[FileAbsent $Path]} { continue }
regsub "/$Projet/fiches.*" $Path "/$Projet" Dir
# Espionne "$Owner $Dir $Projet"
if {$DestinDefaut=="Projets_Owner"} {
set Destin "Projets_$Owner"
} else {
set Destin $DestinDefaut
}
if { ! [regexp "/" $Destin] } {
set Destin "/gstock/$Destin"
}
file mkdir $Destin
lappend ToDo "file rename $Dir $Destin/"
set Link "/genomics/link/$Projet"
if {[FileAbsent $Link]} {
FaireLire "No $Link"
} else {
if {[file type $Link]!="link"} {
if {[OuiOuNon "$Link is not a link\nDo I skip ? (Otherwize I'll stop)"]} {
continue
} else {
return ""
}
} else {
lappend ToDo "file delete $Link"
}
}
lappend ToDo "file link $Link $Destin/$Projet"
}
if {$Force} {
set DoIt [join $ToDo "\n"]
} else {
set DoIt ""
set DoIt [AfficheListe $ToDo "AvecRetour"]
}
set LesNewPath {}
foreach Do [split $DoIt "\n"] {
eval $Do
if {[regexp {file rename ([^ ]+) ([^ ]+)} $Do Match Dir Destin]} {
lappend LesNewPath $Do
}
}
EspionneL $LesNewPath
return $LesNewPath
}
proc LesInfosDuPoch {} {
set LesCles [list \
Acreuser \
Construct \
Construct1 \
Constructt2 \
INfo1 \
Info1 \
Info2 \
StructHyp \
Target ]
foreach Nom [ListeDesPABs] {
set FI "[HomeRipp]/vrac/infos/$Nom"
if {[FileAbsent $FI]} { continue }
foreach Ligne [LesLignesDuFichier $FI] {
foreach Cle $LesCles {
if {[regexp "^$Cle\:" $Ligne]} {
Espionne "$Nom $Ligne"
InformeSansDemander $Nom $Ligne
}
}
}
}
}
proc GetPicture {} {
foreach Ligne [LesLignesDuFichier GetPicture.html] {
set F $Ligne
set J [file tail $F]
set D [file dirname $F]
regsub ".JPG" $J ".jpg" j
Espionne "$D/www*/thumbs/$j"
set T [glob -nocomplain "$D/www*/thumbs/$j"]
Espionne "T $T"
if {$T==""} { continue }
lappend LeHtml "<center>"
lappend LeHtml "<br/>"
lappend LeHtml "<a href='$F'> <img src='$T'> </a>"
lappend LeHtml "<br/>"
}
SauveLesLignes $LeHtml dans GP.html
exit
}
proc RenommeLesPhotos {} {
set Numero 1000000
foreach Fichier [lsort [glob */P101*]] {
incr Numero 10
set Nouveau "P$Numero"
set Rep [file dirname $Fichier]
file rename $Fichier $Rep/$Nouveau.JPG
}
exit
}
proc PourChristopheRomier {} {
if { ! [OuiOuNon "Ce programme a deja ete lance.\n\
Il cree un .TFAs contenant toute les sequences \
d'apres le readme de Christophe Romier\n\
Dois-je le relancer ?"]} { return "" }
set O(y) "Saccharomyces cerevisae"
set O(p) "Schizosaccharomyces pombe"
set O(h) "Homo sapiens"
set O(ec) "Encephalitozoon cuniculi"
set O(cm) "Cyanidioschyzon merolae"
set O(cyme) $O(cm)
foreach Ligne [LesLignesDuFichier readme] {
if { ! [regexp -nocase {[a-z]} $Ligne]} {continue}
if {[regexp {\* (.+)} $Ligne Match Classe]} { continue }
scan $Ligne "%s" FichierTFAs
lappend LaVue ""
foreach A [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $FichierTFAs $A]
set Entete [EnteteDuTexteTFA $TFA]
set Sequence [QueLaSequenceDuTexteTFA $TFA]
scan $Entete "%s" Access
regsub ">" $Access "" Access
regsub "_" $Access "" Access
if {! [regexp {[a-z]+} $Access o]} { FaireLire $Access }
set Organisme $O($o)
if {[info exists DejaVu($Access)]} { FaireLire "dejavu" }
set DejaVu($Access) $Ligne
set BelleEntete "$Access $Organisme $Access , $Classe"
lappend LaVue $BelleEntete
set BonTFA [SequenceFormatTFA $Sequence $BelleEntete "protbrut"]
lappend LesTFAs $BonTFA
}
}
AfficheVariable [join $LaVue "\n"]
return [SauveLesLignes $LesTFAs dans "AllTogether.tfas"]
}
proc LitPG94 {} {
set I 0
foreach Fichier [lsort [glob "[RepertoireDuGenome]/DeWolfgang/*"]] {
set Definition [IemeLigneDuFichier $Fichier 2]
set Nom "Seq[incr I] "
set NomFic $Nom
if {[regexp {^affy ([0-9]+(_[fr])?_at)} $Definition Match Access]} { set Nom "$Access " ; set NomFic $Access}
if {[regexp {^A[^ ]+} $Definition Match]} { set Nom "" ; set NomFic $Match }
set TFA [SequenceFormatTFA [ContenuDuFichier $Fichier] "$Nom$Definition" "gcg"]
Espionne $TFA
Sauve $TFA dans "[RepertoireDuGenome]/DeWolfgang/$NomFic.tfa"
}
exit
}
proc CorrectEOE {} {
foreach Nom [ListeDesPABs] {
set Fichier "[RepertoireDuGenome]/nuctfa/$Nom"
set Texte [ContenuDuFichier $Fichier]
regsub -all "X" $Texte "N" Texte
Sauve $Texte dans $Fichier
set Fichier "[RepertoireDuGenome]/nucembl/$Nom"
set Texte [ContenuDuFichier $Fichier]
regsub -all "X" $Texte "N" Texte
Sauve $Texte dans $Fichier
}
}
proc LesPDBPourBali3 {} {
foreach Ligne [LesLignesDuFichier "/genomics/link/Bali3/PDB.liste"] {
Espionne $Ligne
scan $Ligne "%s" Access
set TFA [TFADuPDB $Access "ForceSEQRES" ]
Espionne $TFA
set Nom "Pdb_$Access"
regsub ">$Access " $TFA ">$Nom " TFA
set FichierTFA [Sauve $TFA dans "/genomics/link/Bali3/proteome/$Nom"]
lappend LaListe "$Nom $FichierTFA"
}
Espionne [SauveLesLignes $LaListe dans "/genomics/link/Bali3/Bali3.fof"]
exit
}
proc TestDefinitionPartagee {} {
foreach Nom [ListeDesPABs] {
if {[EstUnPABMute $Nom]} { continue }
set Fichier "[RepertoireDuGenome]/blastp/$Nom"
DecortiqueBlast $Fichier 0.001 80 Query lBId lA lDE lProfil lPN
DefinitionPartagee $lDE $Fichier
}
}
proc LesMotsImportants Ligne {
regsub -all "EC " $Ligne "EC_" Ligne
regsub -all -nocase {[^a-z0-9\-_\+\.]} $Ligne " " Ligne
set LesImportants {}
foreach Mot [LesMotsDeLaLigne $Ligne] {
if { ! [regexp -nocase {[a-z]} $Mot]} { continue }
regsub -all {^\.|\.$} $Mot "" Mot
regsub -all {\.} $Mot "_" Mot
lappend LesImportants $Mot
}
return $LesImportants
}
proc DefinitionPartagee {LesDefs {Fichier ""}} {
if {$LesDefs=={}} { return "" }
if {[llength $LesDefs]==1} { return [lindex $LesDefs 0] }
set IDef -1
foreach Def $LesDefs {
set Def [string tolower $Def]
incr IDef
set LesMotsImportants($IDef) [LesMotsImportants $Def]
foreach Mot [set LesMotsImportants($IDef)] {
lappend LesMotsExistants $Mot
lappend LesDefsDuMot($Mot) $IDef
if { ! [info exists Histo($Mot,$IDef)]} { set Histo($Mot,$IDef) 0 }
incr Histo($Mot,$IDef)
}
}
set IDefMax $IDef
set LesMotsExistants [lsort -unique $LesMotsExistants]
foreach Mot $LesMotsExistants {
set Ligne ""
set Rang 0
set Occu 0
set LesScores {}
foreach IDef [NombresEntre 0 $IDefMax] {
if {[info exists Histo($Mot,$IDef)]} {
set Score $Histo($Mot,$IDef)
append Ligne [format "%1d" $Score]
incr Rang $IDef
incr Occu
} else {
set Score 0
append Ligne " "
}
lappend LesScores $Score
}
set LesScoresLisses {}
set LesScoresEtPlus $LesScores
lappend LesScoresEtPlus 0 0 0 0
set LesScoresEtPlus [lrange $LesScoresEtPlus 0 [expr ([llength $LesScoresEtPlus]/5)*5-1]]
foreach {S1 S2 S3 S4 S5} $LesScoresEtPlus {
lappend LesScoresLisses [expr $S1 + $S2 + $S3 + $S4 + $S5]
}
set Rang [expr (1.0*$Rang)/($IDefMax+1)]
set Ligne "[format "%-30s %4.1f %2d" $Mot $Rang $Occu] = [join $LesScoresLisses " "]"
lappend LesLignes $Ligne
lappend ListePourCluspack "$Mot [join $LesScoresLisses " "]"
}
set AllWithGroup [Cluspack $ListePourCluspack "GetAllWithGroup"]
EspionneL $AllWithGroup
foreach MG $AllWithGroup {
scan $MG "%s %s" Mot Groupe
Espionne "GroupeDuMot($Mot) $Groupe"
set GroupeDuMot($Mot) $Groupe
}
foreach Ligne $LesLignes {
scan $Ligne "%s" Mot
Espionne "set Groupe GroupeDuMot($Mot)"
set Groupe [set GroupeDuMot($Mot)]
set LigneAvecGroupe "$Groupe $Ligne"
lappend LesLignesAvecGroupes $LigneAvecGroupe
}
set Page [join [lsort -decreasing -integer -index 0 $LesLignesAvecGroupes] "\n"]
return [AfficheVariable $Page "AvecRetour" $Fichier]
}
proc TestTDomSurSpineAnnotation {} {
package require tdom
# package require tnc
set FichierXml "[HomeRipp]/spine/public/xml/macsim.xml"
set XML [ContenuDuFichier $FichierXml]
set Id [dom parse $XML]
set Root [$Id documentElement]
set NoeudAli [$Root selectNodes "alignment"]
set AlnName [$NoeudAli selectNodes "string(aln-name)"]
Espionne $AlnName
foreach Noeud [$NoeudAli selectNodes "sequence"] {
set SeqName [$Noeud selectNodes "string(seq-name)"]
Espionne "$SeqName"
}
exit
}
proc TestTDomSurSpineTarget {} {
package require tdom
set FichierXml "[HomeRipp]/spine/public/xml/Tpetit.xml"
set XML [ContenuDuFichier $FichierXml]
set Id [dom parse $XML]
set Root [$Id documentElement]
set LesNoeudsTarget [$Root selectNodes {//target[//target/status/@access='PUBLIC']}]
foreach NoeudTarget $LesNoeudsTarget {
set ID [$NoeudTarget selectNodes "string(ID)"]
set NoeudStatus [$NoeudTarget selectNodes "status"]
set Task [$NoeudStatus selectNodes "string(task)"]
set Lab [$NoeudStatus selectNodes "string(lab)"]
Espionne "$ID $Task $Lab"
}
exit
}
proc LesCsDeManu {} {
foreach Nom [ListeDesPABs] {
set CS [CodonStart $Nom]
if {$CS=="" || [regexp "^GroupSize" $CS]} { continue }
InformeSansDemander $Nom "CSP: $CS"
InformeSansDemander $Nom "=CodonStart: ARefaire"
Espionne "$Nom $CS"
}
exit
}
proc DST {{Texte ""} {Action ""} {Espion ""}} {
regexp -all {\:} $Texte "\\:"
if {$Action==""} { set Action "Count" }
if {$Espion==""} { set Espion "Espion" }
if {$Espion=="Espion"} { set Espion 1 } else { set Espion 0 }
set Cumul 0
set LesBons {}
foreach Nom [ListeDesPABs] {
set Info [ExtraitInfo $Nom]
if { ! [regexp -nocase $Texte $Info]} { continue }
incr Cumul
if {$Action=="Count"} { if {$Espion} { Espionne $Cumul } ; continue }
lappend LesBons $Nom
if {$Action=="List" } { if {$Espion} { Espionne $Nom }; continue }
lappend LesTextes "\n$Nom\n$Info"
if {$Action=="Text" } { if {$Espion} { Espionne "\n$Nom\n$Info" } ; continue }
}
if {$Action=="Count"} { return $Cumul }
if {$Action=="List" } { return $LesBons }
if {$Action=="Text" } { return [join $LesTextes "\n"] }
return
}
proc ExisteAussiDansZCB {} {
foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/ExisteAussiDansZCB.lst"] {
scan $Ligne "%s %s %s %s %d" Nom B H P N
set Nar [Narcisse $Nom]
if {$N==0} {
Espionne "$Nom $Nar"
lappend LesNulsParNom "$Nom $Nar"
lappend LesNulsParNar "$Nar $Nom"
continue
}
set Bla [ContenuDuFichier "[RepertoireDuGenome]/blastnAllnucZCB/$Nom"]
set Hit [StringApres "AllnucZCB:" dans $Bla]
set NCB [QuestionDeScience ZCB "ret Narcisse $Hit"]
Espionne "$Nom $Nar $Hit $NCB"
lappend LesHitsParNom "$Nom $Nar $Hit $NCB"
lappend LesHitsParNar "$Nar $Nom $Hit $NCB"
lappend LesHitsParHit "$Hit $NCB $Nom $Nar "
lappend LesHitsParNCB "$NCB $Hit $Nar $Nom "
}
set LesHitsParNom [lsort $LesHitsParNom]
set LesHitsParNar [lsort $LesHitsParNar]
set LesHitsParHit [lsort $LesHitsParHit]
set LesHitsParNCB [lsort $LesHitsParNCB]
set LesNulsParNom [lsort $LesNulsParNom]
set LesNulsParNar [lsort $LesNulsParNar]
SauveLesLignes $LesHitsParNom dans "[RepertoireDuGenome]/fiches/LesHitsParNomGC"
SauveLesLignes $LesHitsParNar dans "[RepertoireDuGenome]/fiches/LesHitsParGC"
SauveLesLignes $LesHitsParHit dans "[RepertoireDuGenome]/fiches/LesHitsParNomCB"
SauveLesLignes $LesHitsParNCB dans "[RepertoireDuGenome]/fiches/LesHitsParCB"
SauveLesLignes $LesNulsParNom dans "[RepertoireDuGenome]/fiches/LesNulsParNomGC"
SauveLesLignes $LesNulsParNar dans "[RepertoireDuGenome]/fiches/LesNulsParNarGC"
exit
}
proc SetupGscope {} {
set LesSetupsPossibles [list \
"ShowDirectoriesOrder" "" "" \
"GlobalVariables" "" "" \
]
set Setup [ChoixParmiJoliDansListe $LesSetupsPossibles]
switch $Setup {
"ModifyAllFonts" { ModifyAllFonts }
"ShowDirectoriesOrder" { LesRepertoiresPourSeeAbyShow "Ask" }
"GlobalVariables" { ModifyGlobalVariables }
}
return $Setup
}
proc QuiContient {Texte {Rep ""}} {
if {$Rep==""} { set Rep "infos" }
set LesBons {}
foreach Nom [ListeDesPABs] {
set Fichier "[RepertoireDuGenome]/$Rep/$Nom"
if { ! [file exists $Fichier]} { continue }
if { ! [regexp -nocase $Texte [ContenuDuFichier $Fichier]]} { continue }
lappend LesBons $Nom
}
return $LesBons
}
proc ConvertAllGCG {{Rep ""} {Ext ".seq"}} {
if {$Rep==""} { set Rep [ChoixDuRepertoire [RepertoireDuGenome]]}
if {$Rep==""} { return "" }
foreach Fichier [glob "$Rep/*$Ext"] {
set Entete ""
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp {\.\. *$} $Ligne]} {break}
if {[regexp "!!NA_SEQUENCE" $Ligne]} { continue }
append Entete $Ligne
}
set Entete [string trim $Entete]
scan $Entete "%s" Access
set Access [lindex [split $Access "|"] 1]
set DE [StringSuivant " " dans $Entete]
set TFA [SequenceFormatTFA [ContenuDuFichier $Fichier] "$Access $DE" "gcg"]
lappend LesTFAs $TFA
}
Espionne [SauveLesLignes $LesTFAs dans "$Rep/../all.tfas"]
exit
}
proc Oue {Texte} {
regsub -all "_" $Texte " " Texte
set LesOKs {}
foreach P [LesProceduresExistantes] {
if {[regexp -nocase $Texte [info body $P]]} {
lappend LesOKs $P
foreach Ligne [split [info body $P] "\n"] {
if {[regexp -nocase $Texte $Ligne]} {
lappend LesOKs " | $Ligne"
}
}
}
}
set OKs [join $LesOKs "\n"]
if {[PourWscope]} { return [Html_DuTexteTelQuel $OKs] }
return $OKs
}
proc LesUtilesDeHumanGenome {} {
set LesUtiles {}
foreach Ligne [LesLignesDuFichier "[GscopeDir]/lesrepsdehumangenome.liste"] {
set Quota ""
scan $Ligne "%d %s" Quota Fichier
if {$Quota==""} { continue }
set Xoue [Oue "/$Fichier"]
if {$Xoue==""} { continue }
lappend LesUtiles $Fichier
}
return $LesUtiles
}
proc QuiEstGros {{Action ""} {Quoi ""}} {
if {$Action==""} { set Action "Show" }
if {$Quoi==""} { set Quoi "All" }
set TotL 0
set TotM 0
set TotC 0
set TotP 0
set LaSortie {}
foreach Fichier [LesSourcesDeGscope "Absolu"] {
if { ! [file exists $Fichier]} { continue }
if {[regexp "/etc/" $Fichier]} { continue }
set WC "0 0 0"
catch {set WC [exec wc $Fichier]}
scan $WC "%d %d %d" L M C
set P 0
catch {set P [exec grep proc $Fichier | wc -l]}
if {$M>0} { set X [expr $C/$M] } else { set X 0 }
set WC [format "%8d %8d %8d" $L $M $C]
incr TotL $L
incr TotM $M
incr TotC $C
incr TotP $P
if {[regexp {gscope_contrib/([^/]+)/} $Fichier Match Auteur]} {
regsub {.+/gscope_contrib/} $Fichier "" BeauFichier
} else {
regsub {/home/} $Fichier "" BeauFichier
set Auteur "ripp"
}
if { ! [info exists SonTotL($Auteur)]} {
set SonTotL($Auteur) 0
set SonTotM($Auteur) 0
set SonTotC($Auteur) 0
}
incr SonTotL($Auteur) $L
incr SonTotM($Auteur) $M
incr SonTotC($Auteur) $C
incr SonTotP($Auteur) $P
set Ligne "$WC $BeauFichier"
if {[regexp "NoDetail" $Quoi]} { continue }
Espionne $Ligne
lappend LaSortie $Ligne
}
foreach Auteur [lsort [array names SonTotL]] {
if {$SonTotM($Auteur)>0} { set X [expr $SonTotC($Auteur)/$SonTotM($Auteur)] } else { set X 0 }
set BelAuteur [People $Auteur PrenomNom]
if {$BelAuteur==""} {
set BelAuteur $Auteur
if {$Auteur=="carles"} { set BelAuteur "Annaick CARLES" }
if {$Auteur=="jmuller"} { set BelAuteur "Jean MULLER" }
if {$Auteur=="chalmel"} { set BelAuteur "Frederic CHALMEL" }
if {$Auteur=="lardenoi"} { set BelAuteur "Aurelie LARDENOIS" }
if {$Auteur=="hoffer"} { set BelAuteur "Laurent HOFFER" }
}
# set Ligne [format "%8d %8d %8d %s" $SonTotL($Auteur) $SonTotM($Auteur) $SonTotC($Auteur) "$BelAuteur"]
if {[info exists SonTotL($Auteur)] && [info exists SonTotP($Auteur)] && $SonTotL($Auteur)>0 && $SonTotP($Auteur)} {
set NbCarParLigne [expr $SonTotC($Auteur)/$SonTotL($Auteur)]
set NbLigParProc [expr $SonTotL($Auteur)/$SonTotP($Auteur)]
set Ligne [format "%8d %6d %4d %4d %s" $SonTotL($Auteur) $SonTotP($Auteur) $NbCarParLigne $NbLigParProc "$BelAuteur"]
}
if {[regexp "NoAuthor" $Quoi]} { continue }
Espionne $Ligne
lappend LaSortie $Ligne
}
if {$TotM>0} { set X [expr $TotC/$TotM] } else { set X 0 }
set Ligne [format "%8d %8d %8d %8d %s" $TotL $TotM $TotC $TotP "all together"]
if { ! [regexp "NoTotal" $Quoi]} {
Espionne $Ligne
lappend LaSortie $Ligne
}
set Sortie [join $LaSortie "\n"]
if {$Action=="Show"} { return [AfficheVariable $Sortie "AvecFetch" "QuiEstGros"] }
if {$Action=="GetText"} { return $Sortie }
return $LaSortie
}
proc FreewrapGscope {{GscopeExeDestin ""} {RepDestin ""} {RepRepDestin ""}} {
if { ! [OuiOuNon "Ok to create gscope.exe with freewrap ?"]} { return ""}
while {$GscopeExeDestin==""} {
set GscopeExeDestin [FichierPourSaveAs "[GscopeDir]/gscope.exe"]
if {$GscopeExeDestin!=""} { break }
if {[OuiOuNon "Do I cancel freewrap of gscope ?"]} { return ""}
}
set LesSourcesDeGscope [LesSourcesDeGscope "Relatif" "AvecMain"]
set RepSource [GscopeDir]
while {$RepDestin=="" || [regexp " " $RepDestin] } {
set RepDestin [TmpFile GscopeToWrap $RepRepDestin]
if {[regexp " " $RepDestin]} {
FaireLire "It seems that the name of the temporary directory\n$RepDestin\n \
contains unwanted characters (' '). \
Please browse for a directory where I can create this directory."
set RepRepDestin [ChoixDuRepertoire]
}
}
set LesBonsSourcesDeGscope {}
foreach Source $LesSourcesDeGscope {
set FicSource "$RepSource/$Source"
if { ! [file exists $FicSource]} {
FaireLire "I can't find $Fichier. \nI'll skipp"
}
regsub $RepSource $FicSource $RepDestin FicDestin
set Rep [file dirname $FicDestin]
while {[CreeLeRepertoire $Rep]==""} {
if {[OuiOuNon "I can't create $Rep. Do I stop ?"]} { return "" }
}
file copy $FicSource $FicDestin
lappend LesBonsSourcesDeGscope $Source
}
set GscopeExe "$RepDestin/gscope.exe"
NousAllonsAuBoulot $RepDestin
SauveLesLignes $LesBonsSourcesDeGscope dans "LesSourcesPourFreewrap.txt"
exec c:/bin/freewrap/freewrapBLT.exe -f LesSourcesPourFreewrap.txt
OnRevientDuBoulot
if { ! [file exists $GscopeExe]} {
FaireLire "$GscopeExe\nwas not created. I'll cancel"
return ""
}
while {[catch {file copy -force $GscopeExe $GscopeExeDestin} Message]} {
if { ! [OuiOuNon "I couldn't copy \n $GscopeExe \n to \n $GscopeExeDestin\n \
Do I try again ?" 0]} { return "Error $GscopeExe not copied to $GscopeExeDestin" }
}
return $GscopeExeDestin
}
proc LesAccessFreresDansDecrypthon X {
set LesAccessFreres {}
foreach GM [AutreAccessDansXref $X] {
lappend LesAccessFreres [AutreAccessDansGM $GM]
}
return $LesAccessFreres
}
proc AutreAccessDansXref X {
global LesAccessProtDeDecrypthon LesAccessDecrypthonDeProt
if {[info exists LesAccessProtDeDecrypthon($X)]} { return [set LesAccessProtDeDecrypthon($X)] }
if {[info exists LesAccessDecrypthonDeProt($X)]} { return [set LesAccessDecrypthonDeProt($X)] }
if {[info exists LesAccessDecrypthonDeProt("EstCharge")]} { return "" }
set LesAccessDecrypthonDeProt("EstCharge") 1
set file1 "/decrypthon/XRefs/xrefs_red.dump";
foreach Ligne [LesLignesDuFichier $file1] {
scan $Ligne "%s %s" AD AP
lappend LesAccessProtDeDecrypthon($AD) $AP
lappend LesAccessDecrypthonDeProt($AP) $AD
}
return [AutreAccessDansXref $X]
}
proc AutreAccessDansGM X {
global LesAccessBanqueDeDecrypthon LesAccessDecrypthonDeBanque
if {[info exists LesAccessBanqueDeDecrypthon($X)]} { return [set LesAccessBanqueDeDecrypthon($X)] }
if {[info exists LesAccessDecrypthonDeBanque($X)]} { return [set LesAccessDecrypthonDeBanque($X)] }
if {[info exists LesAccessDecrypthonDeBanque("EstCharge")]} { return "" }
set LesAccessDecrypthonDeBanque("EstCharge") 1
set file2 "/decrypthon/XRefs/GM_REFS";
foreach Ligne [LesLignesDuFichier $file2] {
scan $Ligne "%s %s" AD AB
lappend LesAccessBanqueDeDecrypthon($AD) $AB
lappend LesAccessDecrypthonDeBanque($AB) $AD
}
return [AutreAccessDansGM $X]
}
proc TarDeGscope {{TarDestin ""}} {
if {$TarDestin==""} { set TarDestin "[GscopeDir]/gscope.tar" }
if { ! [regexp "^/" $TarDestin]} { set TarDestin "[pwd]/$TarDestin" }
if { ! [OuiOuNon "Ok to create $TarDestin ?"]} { return ""}
set LesSourcesDeGscope [LesSourcesDeGscope "Relatif" "AvecMain"]
set RepDessus "[GscopeDir]/.."
NousAllonsAuBoulot $RepDessus
if {[file exists $TarDestin]} { file delete $TarDestin }
foreach S $LesSourcesDeGscope {
set BonS "gscope/$S"
Espionne $BonS
set UC "u"
if { ! [file exists $TarDestin]} { set UC "c" }
exec tar -${UC}hf $TarDestin $BonS
}
OnRevientDuBoulot
return $TarDestin
}
proc AfficheLesSourcesDeGscope {{PathType ""} {AvecMain ""} {WithoutOrdali ""}} {
set LesSourcesDeGscope [LesSourcesDeGscope $PathType $AvecMain]
set Page [join $LesSourcesDeGscope "\n"]
set Fen [AfficheVariable $Page "AvecShowFile" "LesSourcesDeGscope_$PathType"]
set B [BoutonneLaFenetre $Fen "Path exact/abs/rel" ""]
bind $B <1> "AfficheLesSourcesDeGscope Exact $AvecMain"
bind $B <2> "AfficheLesSourcesDeGscope Absolute $AvecMain"
bind $B <3> "AfficheLesSourcesDeGscope Relativ $AvecMain"
$B configure -background "green"
}
proc LesSourcesDuProgramme {{PathType ""} {AvecMain ""}} {
#rR Attention ici specifique Gscope
return [LesSourcesDeGscope $PathType $AvecMain]
}
proc LesSourcesDeGscope {{PathType ""} {AvecMain ""}} {
if {$PathType=="" } { set PathType "Relatif" }
if {$AvecMain=="" } { set AvecMain "AvecMain" }
if {$AvecMain=="AvecMain" || $AvecMain=="WithMain"} { set AvecMain 1 } else { AvecMain 0 }
set LesSourcesDeGscope {}
set LesGscopeTcl {}
if {$AvecMain} { lappend LesGscopeTcl "[GscopeDir]/gscope.tcl" }
LConcat LesGscopeTcl [glob "[GscopeDir]/gscope_*.tcl"]
foreach Fichier $LesGscopeTcl {
if {[regexp "obsolete" $Fichier]} { continue }
if {[file isdirectory $Fichier]} { continue }
set Queue [file tail $Fichier]
set Reper [file dirname $Fichier]
if {[regexp -nocase "Exact" $PathType]} {
set Source $Fichier
} elseif {[regexp -nocase "Absol" $PathType]} {
set Source "$Reper/$Queue"
} elseif {[regexp -nocase "Relat" $PathType]} {
set Source "$Queue"
} else {
set Source $Fichier
}
lappend LesSourcesDeGscope $Source
}
foreach Fichier [glob "[GscopeContrib]/*/*.tcl"] {
if {[regexp -nocase "ARanger" $Fichier]} { continue }
if {[regexp -nocase "Poubelle/" $Fichier]} { continue }
if {[regexp "obsolete" $Fichier]} { continue }
if {[file isdirectory $Fichier]} { continue }
set Queue [file tail $Fichier]
if { ! [regexp "^gscope_" $Queue]} { continue }
set ReperUsername [file dirname $Fichier]
set Username [file tail $ReperUsername]
set Reper [file dirname $ReperUsername]
if {[regexp -nocase "Exact" $PathType]} {
set Source $Fichier
} elseif {[regexp -nocase "Absol" $PathType]} {
set Source "$Reper/$Username/$Queue"
} elseif {[regexp -nocase "Relat" $PathType]} {
set Contrib [file tail $Reper]
set Source "$Contrib/$Username/$Queue"
} else {
set Source $Fichier
}
lappend LesSourcesDeGscope $Source
}
foreach Fichier [glob "[GscopeContrib]/*/*/*.tcl"] {
if {[regexp -nocase "ARanger" $Fichier]} { continue }
if {[regexp -nocase "Poubelle/" $Fichier]} { continue }
if {[regexp "AllProcs_CGHviewer.tcl" $Fichier]} { continue }
if {[regexp "obsolete" $Fichier]} { continue }
if {[file isdirectory $Fichier]} { continue }
set Queue [file tail $Fichier]
set ReperUsernameSub [file dirname $Fichier]
set Sub [file tail $ReperUsernameSub]
set ReperUsername [file dirname $ReperUsernameSub]
set Username [file tail $ReperUsername]
set Reper [file dirname $ReperUsername]
if {[regexp -nocase "Exact" $PathType]} {
set Source $Fichier
} elseif {[regexp -nocase "Absol" $PathType]} {
set Source "$Reper/$Username/$Sub/$Queue"
} elseif {[regexp -nocase "Relat" $PathType]} {
set Contrib [file tail $Reper]
set Source "$Contrib/$Username/$Sub/$Queue"
} else {
set Source $Fichier
}
lappend LesSourcesDeGscope $Source
}
foreach Fichier [glob "[GscopeEtc]/*"] {
if {[regexp -nocase "obsolete" $Fichier]} { continue }
if {[file isdirectory $Fichier]} { continue }
if {[regexp "~$" $Fichier]} { continue }
if {[regexp {.[0-9]{4,}$} $Fichier]} { continue }
set Queue [file tail $Fichier]
set Reper [file dirname $Fichier]
if {[regexp -nocase "Exact" $PathType]} {
set Source $Fichier
} elseif {[regexp -nocase "Absol" $PathType]} {
set Source "$Reper/$Queue"
} elseif {[regexp -nocase "Relat" $PathType]} {
set Etc [file tail $Reper]
set Source "$Etc/$Queue"
} else {
set Source $Fichier
}
lappend LesSourcesDeGscope $Source
}
#rR et Ordali
set LesOrdaliTcl [glob "[GscopeDir]/ordali/src/ordali_*.tcl"]
foreach Fichier $LesOrdaliTcl {
if {[regexp "obsolete" $Fichier]} { continue }
if {[file isdirectory $Fichier]} { continue }
set Queue [file tail $Fichier]
set Reper [file dirname $Fichier]
if {[regexp -nocase "Exact" $PathType]} {
set Source $Fichier
} elseif {[regexp -nocase "Absol" $PathType]} {
set Source "$Reper/$Queue"
} elseif {[regexp -nocase "Relat" $PathType]} {
set Source "ordali/src/$Queue"
} else {
set Source $Fichier
}
lappend LesSourcesDeGscope $Source
}
set LesOrdaliEtc [glob -nocomplain "[GscopeDir]/ordali/etc/*"]
foreach Fichier $LesOrdaliEtc {
if {[regexp "obsolete" $Fichier]} { continue }
if {[file isdirectory $Fichier]} { continue }
set Queue [file tail $Fichier]
set Reper [file dirname $Fichier]
if {[regexp -nocase "Exact" $PathType]} {
set Source $Fichier
} elseif {[regexp -nocase "Absol" $PathType]} {
set Source "$Reper/$Queue"
} elseif {[regexp -nocase "Relat" $PathType]} {
set Source "ordali/etc/$Queue"
} else {
set Source $Fichier
}
lappend LesSourcesDeGscope $Source
}
set LesOrdaliDoc [glob -nocomplain "[GscopeDir]/ordali/doc/*"]
foreach Fichier $LesOrdaliDoc {
if {[regexp "obsolete" $Fichier]} { continue }
if {[file isdirectory $Fichier]} { continue }
set Queue [file tail $Fichier]
set Reper [file dirname $Fichier]
if {[regexp -nocase "Exact" $PathType]} {
set Source $Fichier
} elseif {[regexp -nocase "Absol" $PathType]} {
set Source "$Reper/$Queue"
} elseif {[regexp -nocase "Relat" $PathType]} {
set Source "ordali/doc/$Queue"
} else {
set Source $Fichier
}
lappend LesSourcesDeGscope $Source
}
#rR Attention On a rajoute le / en fin de lib ... car il nous faut toute l'arborescence.
set Fichier "[GscopeDir]/ordali/lib"
set Queue [file tail $Fichier]
set Reper [file dirname $Fichier]
if {[regexp -nocase "Exact" $PathType]} {
set Source $Fichier
} elseif {[regexp -nocase "Absol" $PathType]} {
set Source "$Reper/$Queue"
} elseif {[regexp -nocase "Relat" $PathType]} {
set Source "ordali/lib"
} else {
set Source $Fichier
}
lappend LesSourcesDeGscope "$Source/" ;#rR avec /
return $LesSourcesDeGscope
}
proc BellesCouleurs {} {
set Max 0
foreach Ligne [LesLignesDuFichier "$GscopeEtc/gscope_couleurs.txt"] {
scan $Ligne "%s %s" C H
set Hexa($C) $H
set Color($H) $C
set Max [Maxi [string length $C] $Max]
lappend LesCs $C
}
foreach C $LesCs {
set H [set Hexa($C)]
set c [string tolower $C]
set Ligne [format " %-${Max}s => \"%s\"," "\"$c\"" $H]
Espionne $Ligne
}
exit
}
proc Flo {} {
set FichierHtml "[RepertoireDuGenome]/nucleardbpdblist.html"
set FichierTxt "[RepertoireDuGenome]/nucleardbpdblist.txt"
set Texte [ContenuDuFichier nucleardbpdblist.html]
set Table [ValeurDeLaBalise Table Texte]
set Li 0
set LesEnregistrements {}
while 1 {
set Ligne [ValeurDeLaBalise tr Table]
incr Li
if {$Ligne==""} { break }
set Co 0
set LesMots {}
while {1} {
set Cellule [ValeurDeLaBalise td Ligne]
incr Co
if {$Cellule==""} { break }
set Span [ValeurDeLaBalise span Cellule]
regsub -all "\n" $Span " " Span
regsub {<o\:p></o\:p>} $Span "" Span
if {[regexp -nocase {<a } $Span]} { set Span [ValeurDeLaBalise a Span] }
while {[regexp " " $Span]} { regsub -all " " $Span " " Span }
lappend LesMots $Span
Espionne "$Li $Co $Span"
}
lappend LesEnregistrements [join $LesMots "\t"]
}
SauveLesLignes $LesEnregistrements dans $FichierTxt
exit
}
proc TestOXOC {} {
foreach Nom [ListeDesPABs] {
set X [ExtraitInfo $Nom "Organism"]
set C [ExtraitInfo $Nom "Taxonomy"]
Espionne "$Nom $X $C"
if {[regexp "sapiens" $X] && ! [regexp "sapiens" $C]} { FaireLire $Nom }
if {! [regexp "sapiens" $X] && [regexp "sapiens" $C]} { FaireLire $Nom }
}
exit
}
proc ProfileSegment {AccessFichier {Valeur ""}} {
global ProfileSegment
if {$Valeur!=""} { set ProfileSegment($AccessFichier) $Valeur] }
return [set ProfileSegment($AccessFichier)]
}
proc AfficheProfileSegment {Selection Maniere Fichier} {
scan $Selection "%s" Access
set Page [ProfileSegment "$Access,$Fichier"]
return [AfficheVariable $Page "" "${Access}_of_$Fichier"]
}
proc AfficheLesProfileSegments Fichier {
set LesProfileSegments [DecortiqueProfileSegments $Fichier]
set LesProfileSegmentsTries [lsort -decreasing -real -index 1 $LesProfileSegments]
return [AfficheVariable [join $LesProfileSegmentsTries "\n"] "AvecProfileSegments" $Fichier]
}
proc DecortiqueProfileSegments Fichier {
set LesLignes [LesLignesDuFichier $Fichier]
lappend LesLignes "(Local) PROFILESEGMENTS of: Thats_all_folks"
set LesProfileSegments {}
foreach Ligne $LesLignes {
if {[regexp {\(Local\) PROFILESEGMENTS of} $Ligne]} {
if {[info exists AccessEnCours]} {
lappend LesProfileSegments "$AccessEnCours $Quality $Length $Ratio $Gaps $From $To"
ProfileSegment "$AccessEnCours,$Fichier" [join $LAlignement "\n"]
# set [set PS]($AccessEnCours) [join $LAlignement "\n"]
}
set AccessEnCours [StringApres "PROFILESEGMENTS of:" dans $Ligne]
if {[regexp "Thats_all_folks" $AccessEnCours]} { break }
set From [IntegerApres "from:" dans $Ligne]
set To [IntegerApres "to:" dans $Ligne]
set OnAttentPP 1
set YAS 0
set YAP 0
set LAlignement [list "$AccessEnCours"]
continue
}
if {[regexp {Quality\:} $Ligne]} {
set Quality [FloatApres "Quality:" dans $Ligne]
set Length [IntegerApres "Length:" dans $Ligne]
lappend LAlignement $Ligne
continue
}
if {[regexp {Ratio\:} $Ligne]} {
set Ratio [FloatApres "Ratio:" dans $Ligne]
set Gaps [IntegerApres "Gaps:" dans $Ligne]
lappend LAlignement $Ligne
lappend LAlignement ""
continue
}
if {$OnAttentPP && ! [regexp {\.\. *$} $Ligne]} { continue }
set OnAttentPP 0
if {[regexp "^P" $Ligne]} {
lappend LAlignement $Ligne
lappend LAlignement ""
set YAS 0
set YAP P
continue
}
if {[regexp "^S" $Ligne]} {
lappend LAlignement $Ligne
set YAS 1
set YAP 0
continue
}
if { $YAS && ! $YAP} {
lappend LAlignement $Ligne
continue
}
}
return $LesProfileSegments
}
proc MeilleureFrame {{Quoi ""}} {
if {$Quoi==""} { set Quoi "Histo" }
foreach Nom [ListeDesPABs] {
set Fic "[RepertoireDuGenome]/blastx/$Nom"
if { ! [file exists $Fic]} { continue }
if { ! [regexp {Frame = [\+\-][123]} [ContenuDuFichier $Fic] Frame]} { continue }
regsub "Frame = " $Frame "" F
lappend NF "$Nom $F"
if { ! [info exists Histo($F)]} { set Histo($F) 0 }
incr Histo($F)
}
if {$Quoi=="NomFrame"} { return [lsort -index 1 $NF] }
foreach F [lsort -integer [array names Histo]] {
lappend FHisto "$F [set Histo($F)]"
}
return $FHisto
}
proc LongueurDeLaSequence {Nom {Rep ""}} {
if {$Rep==""} { set Rep "nuctfa" }
set Fic "[RepertoireDuGenome]/$Rep/$Nom"
if {[FileAbsent $Fic]} {return -1}
set Seq [QueLaSequenceDuFichierTFA $Fic]
set L [string length $Seq]
return $L
}
proc LesLongueursDesSequences {{Rep ""} {Quoi ""}} {
if {$Rep==""} { set Rep "nuctfa" }
if {$Quoi==""} { set Quoi "Histo" }
foreach Nom [ListeDesPABs] {
set Fic "[RepertoireDuGenome]/$Rep/$Nom"
if {[FileAbsent $Fic]} {continue}
set Seq [QueLaSequenceDuFichierTFA $Fic]
set L [string length $Seq]
lappend NomLong "$Nom $L"
if { ! [info exists Histo($L)]} { set Histo($L) 0 }
incr Histo($L)
}
if {$Quoi=="NomLongueur"} { return $NomLong }
foreach L [lsort -integer [array names Histo]] {
lappend LHisto "$L [set Histo($L)]"
}
return $LHisto
}
proc TestOnto {} {
Espionne [QuestionDeScience Ontology "ret Onto GO:0003674 Type"]
Espionne [QuestionDeScience Ontology "ret Onto GO:0003674 Type"]
exit
Espionne [QuestionDeScience Ontology "ret ListeDesPABs"]
Espionne [QuestionDeScience Ontology "ret ListeDesPABs"]
exit
}
proc ORFsDesOperonsCommuns {Texte {Action ""}} {
set LesOperonsCommuns [lrange [split $Texte " "] 3 end]
if {$Action=="ORFsOfOperon"} {
foreach Op $LesOperonsCommuns {
set LesORFsDeLOperon [O2C2O Operon $Op LesOrfs]
set LaPage {}
foreach ORF $LesORFsDeLOperon {
lappend LaPage "$ORF [DefinitionApproximative $ORF]"
}
AfficheVariable [join $LaPage "\n"] "" "ORFs_of_operon_$Op"
}
return
}
}
proc AfficheOperonsCommunsAuxClusters {} {
set Fichier "[RepertoireDuGenome]/fiches/operons_communs"
set Texte [ContenuDuFichier $Fichier]
regsub -all "\t" $Texte " " Texte
while {[regexp " " $Texte]} { regsub -all " " $Texte " " Texte }
return [AfficheVariable $Texte "AvecOpCom" $Fichier]
}
proc MultiPro {} {
after 1000 exec gscope IllustreLeBlast "[RepertoireDuGenome]/blastp/PGS001" &
after 1200 AfficheVariable coucou5
FaireLire Salut
after 10000 AfficheVariable coucou10
FaireLire Cava
}
proc LesIlotsSansPointDans {Texte} {
set Start -1
set LesBornes {}
while {[regexp -indices -start $Start {[^\.]+} $Texte Indices]} {
scan $Indices "%d %d" D F
lappend LesBornes "$D $F"
set Start [expr $F+1]
}
return $LesBornes
}
proc CreeLeFichierTFAsDesRNsDeCbriggsae {} {
set LesTFAs {}
foreach Ligne [LesRecepteursNucleairesDe "briggsae"] {
scan $Ligne "%s %s" Bidon Access
if {[info exists DejaVu($Access)]} { continue }
set DejaVu($Access) 1
set TFA [LaSequenceDuTFAs "/catalog/blast/Cbriggsae" $Access]
lappend LesTFAs $TFA
}
Espionne [SauveLesLignes $LesTFAs dans "[RepertoireDuGenome]/Cbriggsae_nr.tfa"]
}
proc LesRNsDeYann {} {
foreach Nom [ListeDesPABs] {
set TexteNR [ExtraitInfo $Nom NR]
if { ! [regexp "oui" $TexteNR]} { continue }
regsub "oui " $TexteNR "" GN
scan $GN "%s" GN
InformeSansDemander $Nom "=ValiGN: $GN"
lappend LesNRsDeYann "$Nom $GN"
}
SauveLesLignes $LesNRsDeYann dans "[RepertoireDuGenome]/fiches/les_nr_de_yann"
exit
}
proc CreeBornesDesPABsDuFichierSubset FichierSubset {
set LesNoms {}
foreach Ligne [LesLignesDuFichier $FichierSubset] {
set Nom ""
scan $Ligne "%s" Nom
if { ! [EstUnPAB $Nom]} { continue }
lappend LesNoms $Nom
}
if {$LesNoms=={}} { return "" }
set OldFin 101
foreach Nom $LesNoms {
set FTFA "[RepertoireDuGenome]/prottfa/$Nom"
set Long [expr [string length [QueLaSequenceDuFichierTFA $FTFA]] * 3]
set Debut [expr $OldFin + 101]
set Fin [expr $Debut+$Long-1]
lappend LesNouvellesBornes "$Nom $Debut $Fin F"
set OldFin $Fin
}
set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
Garde $FichierBornes
SauveLesLignes $LesNouvellesBornes dans $FichierBornes
exit
}
proc BlastPPourTousDuFichier Fichier {
set LesNoms {}
foreach Ligne [LesLignesDuFichier $Fichier] {
set Nom ""
scan $Ligne "%s" Nom
if { ! [EstUnPAB $Nom]} { continue }
lappend LesNoms $Nom
}
if {$LesNoms=={}} { return "" }
BlastPPourTous $LesNoms
}
proc LesRecepteursNucleairesDe {{Qui ""}} {
if {$Qui==""} {
set LesPossibles [glob -nocomplain "[RepertoireDuGenome]/blastp*"]
set Qui [ChoixParmi $LesPossibles]
if {$Qui==""} { return {} }
set Qui [file tail $Qui]
regsub "blastp" $Qui "" Qui
}
foreach Nom [ListeDesPABs] {
set Fichier "[RepertoireDuGenome]/blastp$Qui/$Nom"
DecortiqueBlast $Fichier 0.001 9999 Query lBanqueId lAccess lDE lProfil lPN
if {$Qui=="briggsae"} { set lAccess $lBanqueId }
foreach Access $lAccess PN $lPN {
lappend VerExpect($Access) "$PN $Nom"
}
}
set LesRNs {}
foreach Access [lsort [array names VerExpect]] {
set VerExpect($Access) [lsort -command CompareLesFloatsEnDebut [set VerExpect($Access)]]
if {$Qui=="Ciona"} {
set CIONA [CioNarcisse $Access]
lappend LesRNs "$CIONA $Access [join [set VerExpect($Access)] { }]"
} else {
lappend LesRNs "xxxxxx $Access [join [set VerExpect($Access)] { }]"
}
}
return $LesRNs
}
proc OrgPourCiona {} {
set OS [NotreOS]
set OC [OCduOS $OS]
set OSOC "OS $OS.\nOC $OC"
foreach Nom [ListeDesPABs] {
set F "[RepertoireDuGenome]/protembl/$Nom"
set Texte [ContenuDuFichier $F]
regsub "CC " $Texte "$OSOC\nCC " Texte
Sauve $Texte dans $F
}
exit
}
proc CioNarcisse A {
global CioNarcisse
if {[info exists CioNarcisse($A)]} { return [set CioNarcisse($A)] }
if {[info exists CioNarcisse("EstCharge")]} { return $A }
set CioNarcisse("EstCharge") 1
foreach Ligne [LesLignesDuFichier "/genomics/link/Ciona/fiches/narcisse"] {
set X ""
set Y ""
scan $Ligne "%s %s" X Y
set CioNarcisse($X) $Y
set CioNarcisse($Y) $X
}
return [CioNarcisse $A]
}
proc LesOrganismesDuHTML Fichier {
set Texte [ContenuDuFichier $Fichier]
set OL [ValeurDeLaBalise "ol" Texte]
set LesOrganismes {}
while 1 {
set B [ValeurDeLaBalise "li" OL]
if {$B==""} { break }
set iPV [string last ";" $B]
set Champ [string range $B [incr iPV] end]
set iP [string last "<P>" $Champ]
if {$iP>=0} {
set Champ [string range $Champ 0 [incr iP -1]]
}
regsub { *\(.*} $Champ "" Organisme
if {[info exists DejaVu($Organisme)]} { continue }
set DejaVu($Organisme) 1
lappend LesOrganismes $Organisme
}
return $LesOrganismes
exit
}
proc SansNarcisse {} {
foreach Nom [ListeDesPABs] {
if {[Narcisse $Nom]==""} { Espionne $Nom }
set FichierBlastP "[RepertoireDuGenome]/blastp/$Nom"
if { ! [file exists $FichierBlastP]} { Espionne "$Nom Sans Blastp" }
# AfficheFichier $FichierBlastP "AvecSegAlignement"
}
}
proc CorrelationClustersOperons {aT} {
upvar $aT T
global TableauOrf2Cluster2Operon
set LesClusters [lsort -integer [O2C2O LesClusters]]
set LesOperons [lsort -integer [O2C2O LesOperons]]
foreach Cluster [lrange $LesClusters 0 10] {
set LesOperonsDuCluster [lsort -integer [O2C2O Cluster $Cluster LesOperons]]
foreach Operon $LesOperonsDuCluster {
if {[info exists TableauOrf2Cluster2Operon(Cluster,$Cluster,Operon,$Operon,LesOrfsEnCommun)]} {
set LesOrfs [O2C2O Cluster $Cluster Operon $Operon LesOrfsEnCommun]
set nOrfs [llength $LesOrfs]
} else {
set nOrfs 0
}
set TailleOperon [O2C2O Operon $Operon TailleOperon]
if {$TailleOperon!=0} {
set P [expr ($nOrfs*100)/$TailleOperon]
} else {
set P 0
}
set T($Cluster,$Operon) [list $P $nOrfs [expr $nOrfs!=0]]
}
}
return [list $LesClusters $LesOperons]
}
proc AfficheCorrelationClustersOperons {} {
global TableauOrf2Cluster2Operon
set CO [CorrelationClustersOperons TCCO]
set LesXs [lindex $CO 0]
set LesYs [lindex $CO 1]
DessineBilanHDACroises $LesXs $LesYs TCCO "CorrelationClustersOperons"
}
proc AfficheToutesLesDefinitions {} {
#rR je sais pas si ca marche ....???????????????
set Sortie {}
foreach Operon [lrange [LesOperons] 0 10] {
set Premier [lindex $Operon 0]
set LesDefs [Operon $Premier "Definitions"]
lappend Sortie ""
lappend Sortie $Operon
foreach Def $LesDefs {
lappend Sortie " $Def"
}
}
return [AfficheVariable [join $Sortie "\n"] "" ""]
}
proc TL {} {
foreach Orf [lrange [ListeDesPABs] 1 10] {
foreach Orga [FamiliarOrganism LaListeMerci] {
Espionne [Glossaire $Orga Demi]
}
}
exit
}
proc VraiChemin Chemin {
set MemoWD [pwd]
if { ! [file isdirectory $Chemin]} {
set Dir [file dirname $Chemin]
set Queue [file tail $Chemin]
} else {
set Dir $Chemin
}
if {[catch { cd $Dir } ]} { return $Chemin }
set VraiChemin [pwd]
if {[info exists Queue]} { append VraiChemin "/$Queue" }
cd $MemoWD
return $VraiChemin
}
proc CompareChroDebutFin {A B} {
scan $A "%s %s %d %d" NomA CA DA FA
scan $B "%s %s %d %d" NomB CB DB FB
if {[set C [string compare $CA $CB]]} { return $C }
if { $DA < $DB } { return -1 }
if { $DA > $DB } { return 1 }
if { $FA < $FB } { return -1 }
if { $FA > $BB } { return 1 }
return 0
}
proc BornesLocales {SequencePointee dG fG} {
#lm change pour version plus rapide
set sd [string range $SequencePointee 0 $dG-1]
set sf [string range $SequencePointee 0 $fG-1]
set id [string length [string map {"." "" "-" "" "~" ""} $sd]]
set if [string length [string map {"." "" "-" "" "~" ""} $sf]]
return [list $id $if]
}
proc BornesLocalesRaymond {SequencePointee dG fG} {
#rR on a pris celui de luc ci-dessus
set iL 0
set iG 0
foreach C [split $SequencePointee ""] {
#Espionne $C $iG $iL
incr iG
if {[string equal $C "."]} { continue }
# if {[regexp {[0-9]} $C]} { continue }
incr iL
if {$iG>$fG} {
#Espionne $iG $iL $dG $fG je sors
break
}
if {$iG>=$dG && ! [info exists dL]} { set dL $iL }
if {[info exists dL]} { set fL $iL }
}
if {[info exists dL]} { return "$dL $fL" }
return "-1 -1"
}
proc ShowIp {} {
global Ip CafeDesSciencesDir
DecortiqueIpCafeScience "coucou" I C S
return "$CafeDesSciencesDir $I $C $S $Ip"
}
proc TestSocket {} {
# set Reponse [QuestionDeScience]
set SocketLBGS [socket lbgs.u-strasbg.fr 80]
puts $SocketLBGS "GET /people/peoplealpha.php\n"
gets $SocketLBGS Reponse
puts $Reponse
exit
while {1} {
Espionne [socket ouragan 20000]
}
exit
Espionne [socket ouragan 20000]
Espionne [catch {set Soso [socket ouragan 20001]} Message]
Espionne $Soso
Espionne $Message
Espionne [socket ouragan 25000]
Espionne [socket ouragan 25001]
exit
}
proc RemplaceSetCloClo {Fichier} {
foreach Ligne [LesLignesDuFichier $Fichier] {
if {![regexp "set CloClo" $Ligne]} {
lappend Sortie $Ligne
continue
}
if {[regexp {(^|\{)[ \t]*set CloClo} $Ligne]} {
set ClonInventorySet 1
} else {
set ClonInventorySet 0
}
regexp -nocase {set CloClo\(([\$0-9a-z_:]+[\,\)])+} $Ligne Match
regsub -all {[\,\(]} $Match " " Bon
regsub -all {\)} $Bon "" Bon
if {$ClonInventorySet} {
regsub "set CloClo" $Bon "ClonInventorySet" Bon
} else {
regsub "set CloClo" $Bon "ClonInventory" Bon
}
regexp -nocase -indices {set CloClo\(([\$0-9a-z_:]+[\,\)])+} $Ligne Indices
scan $Indices "%d %d" D F
set Nouveau [string replace $Ligne $D $F $Bon]
regsub "unClonInventory" $Nouveau "ClonInventoryUnset" Nouveau
Espionne "\n$Ligne\n$Nouveau"
lappend Sortie $Nouveau
unset Match
}
if {[OuiOuNon "Je sauve dans $Fichier.nouveau ?" ]} {
Espionne [SauveLesLignes $Sortie dans "$Fichier.nouveau"]
}
exit
}
proc RemplaceCloCloExists {Fichier} {
foreach Ligne [LesLignesDuFichier $Fichier] {
if {![regexp "info exists CloClo" $Ligne]} {
lappend Sortie $Ligne
continue
}
regexp -nocase {info exists CloClo\(([\$0-9a-z_:]+[\,\)])+} $Ligne Match
regsub -all {[\,\(]} $Match " " Bon
regsub -all {\)} $Bon "" Bon
regsub "info exists CloClo" $Bon "ClonInventoryExists" Bon
regexp -nocase -indices {info exists CloClo\(([\$0-9a-z_:]+[\,\)])+} $Ligne Indices
scan $Indices "%d %d" D F
set Nouveau [string replace $Ligne $D $F $Bon]
Espionne "\n$Ligne\n$Nouveau"
lappend Sortie $Nouveau
unset Match
}
if {[OuiOuNon "Je sauve dans $Fichier.nouveau ?" ]} {
Espionne [SauveLesLignes $Sortie dans "$Fichier.nouveau"]
}
exit
}
proc MiseAJourDesNomsDeVariables Fichier {
set Texte [ContenuDuFichier HGE1034757799155101]
set LesMots [split $Texte "&"]
foreach Mot $LesMots {
ScanLaListe [split $Mot "="] Var Val
lappend LesBonnesVars $Var
}
set Texte [ContenuDuFichier $Fichier]
set LesMots [split $Texte "&"]
foreach Mot $LesMots BonneVar $LesBonnesVars {
ScanLaListe [split $Mot "="] Var Val
lappend LesVarVal "$BonneVar=$Val"
}
Espionne [Sauve [join $LesVarVal "&"] dans $Fichier.nouveau]
exit
}
proc LisBox {Conteneur {Liste {}} {LesIllumines {}}} {
frame $Conteneur -borderwidth 10
pack $Conteneur -side left -expand yes -fill both
set LixBox "$Conteneur.list"
scrollbar $Conteneur.yscroll -command "$LixBox yview"
scrollbar $Conteneur.xscroll -command "$LixBox xview" -orient horizontal
set Largeur 30
set Hauteur 35
listbox $LixBox -width $Largeur -height $Hauteur -setgrid 1 \
-yscroll "$Conteneur.yscroll set" \
-xscroll "$Conteneur.xscroll set" \
-selectmode extended \
-background "LightGrey" \
-foreground "Black" \
-selectbackground "LightYellow" \
-selectforeground "Black" \
-font [list Courier [PolicePourListBox]]
grid $LixBox -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
grid $Conteneur.yscroll -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
grid $Conteneur.xscroll -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
grid rowconfig $Conteneur 0 -weight 1 -minsize 0
grid columnconfig $Conteneur 0 -weight 1 -minsize 0
bind $LixBox <3> "DecrisLaLigne %W %x %y"
bind $LixBox <ButtonRelease-3> "DecrisLaLigne %W %x %y Efface"
foreach Element $Liste {
$LixBox insert end $Element
}
foreach Nom $LesIllumines {
Illumine $Nom $LixBox
}
return $LixBox
}
proc Passeur {LisBoxDep LisBoxArr} {
set LesPasses {}
foreach i [$LisBoxDep curselection] {
set Passe [$LisBoxDep get $i]
lappend LesPasses $Passe
$LisBoxArr insert end $Passe
}
return $LesPasses
}
proc Ordonateur {LisBox Action} {
if {$Action=="KillAll"} {
set LesPasses [$LisBox get 0 end]
$LisBox delete 0 end
return $LesPasses
}
set LesPasses {}
set LesI [$LisBox curselection]
if {$Action=="Up"} {
set LesI $LesI
} else {
set LesI [lsort -decreasing $LesI]
}
foreach I $LesI {
set Passe [$LisBox get $I]
lappend LesPasses $Passe
$LisBox delete $I
if {$Action=="Kill"} { continue }
if {$Action=="Up"} { set D [expr $I-1] }
if {$Action=="Down"} { set D [expr $I+1] }
$LisBox insert $D $Passe
$LisBox selection set $D
}
return $LesPasses
}
proc MorceauxChoisisAndMore {LesExistants {LesIllumines ""} {Texte ""}} {
set LesPossibles $LesExistants
set LesBons {}
while {1} {
set LesBons [MorceauxChoisis $LesPossibles $LesBons \
"$Texte\nPlease select lines in the left window and press '--->'\n\
Reorder with 'Up' and 'Down' if necessary.\n\
Press 'More' if you want to add your own file."]
if {$LesBons=={} && [OuiOuNon "Do You want an empty list ?"]} { return {} }
if {$LesBons=={} && [OuiOuNon "Do You want to select your own files ?"] \
|| [lindex $LesBons end]=="MorePlease"} {
if {[OuiOuNon "Do You want to paste a selection ?"]} {
set Sel [selection get]
set LesPersos [split $Sel "\n"]
LConcat LesPossibles $LesPersos
} else {
if {[OuiOuNon "Do we add flat files (no directories) ?"]} {
set Perso [ButineArborescence "All" "."]
if {$Perso!=""} { lappend LesPossibles $Perso }
} else {
set Perso [ChoixDuRepertoire]
if {$Perso==""} { continue }
set LesPerso [glob -nocomplain -type f "$Perso/*"]
if {$LesPerso!=""} { LConcat LesPossibles $LesPerso }
}
}
continue
} elseif {[lindex $LesBons end]=="Selection"} {
FaireLire "Enter a regular expression to select some of these files"
set ExpReg [Entre "YOURTEXT"]
set LesNouveauxPossibles {}
foreach Possi $LesPossibles {
if { ! [regexp $ExpReg $Possi]} { continue }
lappend LesNouveauxPossibles $Possi
}
set LesPossibles $LesNouveauxPossibles
continue
} else {
break
}
}
return $LesBons
}
proc MorceauxChoisis {ListeDeDepart {LesIllumines {}} {Texte ""}} {
global VariableDeRetour
set w [NomDe fenetre]
toplevel $w -width 1024
if {$Texte!=""} {
set FrameMessage "$w.texte"
frame $FrameMessage
pack $FrameMessage -side top -expand yes
set Message "$FrameMessage.message"
message $Message -text "$Texte" -width 800
pack $Message
}
set FrameLisBouLis "$w.lisboulis"
frame $FrameLisBouLis
pack $FrameLisBouLis -side top -expand yes -fill both
set LisBoxDep [LisBox "$FrameLisBouLis.fraDep" $ListeDeDepart $LesIllumines]
set FraBou "$FrameLisBouLis.panneau"
frame $FraBou
pack $FraBou -side left
set LisBoxArr [LisBox "$FrameLisBouLis.fraArr"]
set Passeur "$FraBou.passeur"
button $Passeur -text "--->" -background "green" -width 10 -height 2
bind $Passeur <1> "Passeur $LisBoxDep $LisBoxArr"
pack $Passeur
set Vide0 "$FraBou.vide0"
button $Vide0 -relief "flat" -height 1
pack $Vide0
set Aide "$FraBou.aide"
button $Aide -text "Help" -background "blue" -width 6 -height 1
bind $Aide <1> "FaireLire {Select lines in the left window,\n\
then transfer them to the right window pressing the '--->' button\n\n\
To reorder in the right window, select a line and press 'Up' or 'Down'\n\
To remove one line in the right window, select it and press 'Remove sel'\n\n\
Accept ALL LINES in the RIGHT window by pressing 'Accept'.}"
pack $Aide
set Vide1 "$FraBou.vide1"
button $Vide1 -relief "flat" -height 2
pack $Vide1
set Monteur "$FraBou.monteur"
button $Monteur -text " Up ^" -background "lightblue" -width 8
bind $Monteur <1> "Ordonateur $LisBoxArr Up"
pack $Monteur
set Tombeur "$FraBou.tombeur"
button $Tombeur -text "Down v" -background "lightblue" -width 8
bind $Tombeur <1> "Ordonateur $LisBoxArr Down"
pack $Tombeur
set Vide2 "$FraBou.vide2"
button $Vide2 -relief "flat"
pack $Vide2
set Killeur "$FraBou.killeur"
button $Killeur -text "Remove sel ->" -background "orange" -width 10
bind $Killeur <1> "Ordonateur $LisBoxArr Kill"
pack $Killeur
set KillAll "$FraBou.killAll"
button $KillAll -text "Remove all =>" -background "orange" -width 10
bind $KillAll <1> "Ordonateur $LisBoxArr KillAll"
pack $KillAll
set Vide3 "$FraBou.vide3"
button $Vide3 -relief "flat"
pack $Vide3
set Vide4 "$FraBou.vide4"
button $Vide4 -relief "flat"
pack $Vide4
set Accept "$FraBou.accept"
button $Accept -text "Accept ->" -background "green" -width 10 -height 2
bind $Accept <1> "set VariableDeRetour($w) \[$LisBoxArr get 0 end\]"
pack $Accept
if {[regexp -nocase {Press ('More'|'All')} $Texte]} {
set More "$FraBou.more"
button $More -text "<- More/Sel/All" -background "yellow" -width 10
bind $More <1> "set VariableDeRetour($w) \[concat \[$LisBoxArr get 0 end\] MorePlease\]"
bind $More <2> "set VariableDeRetour($w) \[concat \[$LisBoxArr get 0 end\] Selection\]"
bind $More <3> "Illumine \".\" $LisBoxDep"
pack $More
}
set Vide5 "$FraBou.vide5"
button $Vide5 -relief "flat"
pack $Vide5
set Cancel "$FraBou.cancel"
button $Cancel -text "Cancel" -background "red" -width 8
bind $Cancel <1> "set VariableDeRetour($w) {}"
pack $Cancel
tkwait variable VariableDeRetour($w)
set v $VariableDeRetour($w)
unset VariableDeRetour($w)
catch {destroy $w}
return $v
}
proc SubstitueHtml {FichierOuTexte} {
set Texte $FichierOuTexte
if { ! [regexp "<" $Texte] && [file exists $FichierOuTexte]} {
set Texte [ContenuDuFichier $FichierOuTexte]
}
while {[regexp {_=([^=]*)=_} $Texte Match Variable]} {
Espionne $Variable
if {[uplevel info exists $Variable]} {
set Nouveau [uplevel set $Variable]
} else {
set Nouveau ""
}
set d [string first $Match $Texte]
set f [expr $d+[string length $Match]-1]
set Texte [string replace $Texte $d $f $Nouveau]
}
return $Texte
}
proc MomentUnique {{Type ""}} {
global DataSetElemIncr
if { ! [info exists DataSetElemIncr]} { set DataSetElemIncr 100 }
set DataSetElemIncr [expr [incr DataSetElemIncr]%1000]
set NewElem "[clock clicks -milliseconds]$DataSetElemIncr"
return "$Type$NewElem"
}
proc TriHKL Fichier {
set Sortie {}
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%5d %5d %5d %f %f %f %f %f %f %f %f" \
h k l Fp SFp Fm SFm F SF DF SDF
puts "$h $k $l"
if {$SDF<0} { continue }
if {$SFm<0} { set SFm 0 }
lappend Sortie [format "%5d%5d%5d%12.4e%12.4e%12.4e%12.4e%12.4e%12.4e%12.4e%12.4e" \
$h $k $l $Fp $SFp $Fm $SFm $F $SF $DF $SDF]
}
puts [SauveLesLignes $Sortie dans "$Fichier.nouveau"]
}
proc Random {} {
set n 30
while {[incr n -1]} {
set F [expr round(rand()*30)]
set S [expr round(rand()*50)]
if {$S<=10} { set F [expr -$F] }
puts [expr $F/10]
}
exit
}
proc TesteUnCanva {} {
set K [UnCanva 600 600 600 600 EtY]
set K2 [UnCanva 600 800 6000 8000 EtY]
$K create rectangle 200 200 300 500 -fill red
set I [image create photo ima -file [HomeRipp]/images/hammer.gif]
$K create image 0 0 -anchor nw -image ima
MainLeveeSurUnCanva $K
}
proc OuSontLesProcedures {{aFichierContenant ""}} {
global GscopeDir GscopeContrib
if {$aFichierContenant!=""} { upvar $aFichierContenant FichierContenant }
set LesFichiersTcl [glob $GscopeDir/gscope*.tcl $GscopeContrib/*/*.tcl /home/moumou/ordali/ordali_*.tcl]
set ToutesLesNomProc {}
foreach Fichier $LesFichiersTcl {
if {[regexp "obsolete" $Fichier]} { continue }
set LesNomProc [LesProceduresDuFichier $Fichier FichierContenant]
LConcat ToutesLesNomProc $LesNomProc
}
foreach NomProc $ToutesLesNomProc {
if {[info exists DejaVu($NomProc)]} {
# Espionne [format "%-30s %s" $NomProc [set FichierContenant($NomProc)]]
}
set DejaVu($NomProc) 1
}
return $ToutesLesNomProc
}
proc LesProceduresDuFichier {Fichier {aFichierContenant ""}} {
if {$aFichierContenant!=""} { upvar $aFichierContenant FichierContenant }
global GscopeDir
if { ! [regexp "/" $Fichier] } {
set Fichier "$GscopeDir/$Fichier"
}
if { ! [file exists $Fichier]} { return {} }
set LesNomProc {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {^proc +([A-Z][a-zA-Z0-9_]+) +[\{[a-zA-Z)]} $Ligne Match NomProc]} { continue }
lappend FichierContenant($NomProc) $Fichier
lappend LesNomProc $NomProc
}
return $LesNomProc
}
proc SourceAutonome {Fichier args} {
global GscopeDir GscopeContrib
if { ! [regexp "/" $Fichier] } {
set Fichier "$GscopeDir/$Fichier"
}
foreach Supplement $args {
if { ! [regexp "/" $Supplement] } {
set Supplement "$GscopeDir/$Supplement"
}
set EstSupplement($Supplement) 1
}
OuSontLesProcedures FichierContenant
set LesNomProc [LesProceduresDuFichier $Fichier]
foreach NomProc $LesNomProc {
if {[regexp "^Teste_" $NomProc]} { continue }
foreach Appelee [QuiJAppel $NomProc "LaListeMerci"] {
if {[info exists FichierContenant($Appelee)]} {
set Contenant [set FichierContenant($Appelee)]
} else {
set Contenant "non_trouve"
}
if {$Contenant==$Fichier || [info exists EstSupplement($Contenant)]} { continue }
Espionne [format "%-30s %-30s %s" $NomProc $Appelee $Contenant]
}
}
exit
}
proc SupprimeVide Fichier {
foreach Ligne [LesLignesDuFichier $Fichier] {
if {$Ligne==""} { continue }
puts $Ligne
}
exit
}
proc FindNode {Value T} {
#returns the first node with that value
return [lindex [PathToNode $Value $T "value"] end]
}
proc PathToNode {N T {WhatToTest "link"}} {
if {$WhatToTest=="link" && $N==$T || \
$WhatToTest=="value" && $N==[ValueOfTree $T] } {
return [list $T]
}
foreach B [Branches $T] {
set Path [PathToNode $N $B $WhatToTest]
if {$Path=={}} { continue }
return [linsert $Path 0 $T]
}
return {}
}
proc SwapRoot {T N {Path ""}} {
#The node N becomes the new root"
JeMeSignale
puts "SwapRoot [ValueOfTree $T] [ValueOfTree $N] $Path"
if {$T==$N} { return $T }
if {$Path==""} { set Path [PathToNode $T $N] }
set Bonne [lindex $Path 1]
set Haut [CutBranch $T $Bonne]
DataSet linksappend $Bonne $Haut
set Swap [SwapRoot $Bonne $N [lrange $Path 1 end]]
return $Swap
}
proc Spy T {
JeMeSignale
puts [$T dump root]
}
proc CreateNode {T {Where "root"} args} {
if {$args=={}} {
set Id [$T insert $Where]
} else {
set Id [$T insert $Where $args]
}
$T tag add "IAm$Id" $Id
$T label $Id "memelabel"
return $Id
}
proc TT {} {
puts [string repeat "*" 600]
package require BLT
set T [blt::tree create]
set I1 [CreateNode $T]
Spy $T
puts "insert de $I1 dans $T en root"
$T root $I1
puts "$I1 devient root"
Spy $T
set I2 [CreateNode $T]
puts "insert de $I2 dans $T en root"
Spy $T
set I3 [CreateNode $T]
puts "insert de $I3 dans $T en root"
Spy $T
set I4 [CreateNode $T $I3]
puts "insert de $I4 dans $T en $I3"
Spy $T
set I5 [CreateNode $T $I4]
puts "insert de $I5 dans $T en $I4"
Spy $T
set TV ".tv"
blt::treeview $TV -tree $T
$TV open all
pack $TV
puts "ai trouve [$T path "IAm4"]"
set R [NewRoot $T "IAm4"]
set RV ".rv"
blt::treeview $RV -tree $R
$RV open all
pack $RV
}
proc TestDataSet {} {
global DataSet
set A [DataSet create AAA]
set B [DataSet create BBB]
set C [DataSet create CCC]
DataSet father $B $A
DataSet linksappend $A $C
DataSet spyAll $A
set Z [DataSet clone $A]
DataSet updateFather $Z
foreach X [concat [list $A $B $C $Z] [DataSet links $Z]] {
DataSet spyAll $X
}
exit
Grave DataSet
exit
}
proc DataSet {Action {Elem ""} {Val "GetStoredValue"}} {
global DataSet DataSetElemIncr
if {[string equal $Action "create"]} {
if { ! [info exists DataSetElemIncr]} { set DataSetElemIncr 100 }
set DataSetElemIncr [expr [incr DataSetElemIncr]%1000]
set NewElem "[clock clicks -milliseconds]$DataSetElemIncr"
set DataSetElem $NewElem
set DataSet($NewElem,value) $Elem
set DataSet($NewElem,father) ""
if {[string equal $Val "GetStoredValue"]} {
set DataSet($NewElem,links) {}
} else {
set DataSet($NewElem,links) $Val
}
return $NewElem
}
if {[string equal $Action "hasBranches"]} {
return [llength [DataSet links $Elem]]
}
if {[string equal $Action "isLeaf"]} {
return [expr ! [DataSet hasBranches $Elem]]
}
if {[string equal $Action "spy"]} {
set Texte "$Elem Value<[DataSet value $Elem]> Father<[DataSet father $Elem]> Links<[DataSet links $Elem]>"
if { ! [string equal $Val "Get"]} { puts $Texte }
return $Texte
}
if {[string equal $Action "spyAll"]} {
if {[string equal $Val "GetStoredValue"]} { set Val 0 }
set Indent $Val
set Indentation [string repeat " " $Indent]
puts "$Indentation[DataSet spy $Elem Get]"
incr Indent
foreach Son [DataSet links $Elem] {
DataSet spyAll $Son $Indent
}
return ""
}
if {[string equal $Action "findValue"]} {
set TheElements {}
foreach {C V} [array get DataSet] {
if { ! [regsub {,value$} $C "" E]} { continue }
if { [DataSet value $E]==$Elem } { lappend TheElements $E }
}
return $TheElements
}
if {[string equal $Action "updateFather"]} {
foreach Son [DataSet links $Elem] {
DataSet father $Son $Elem
DataSet updateFather $Son
}
return $Elem
}
if {[string equal $Action "clonedSonsOf"]} {
set TheClonedSons {}
foreach Son [DataSet links $Elem] {
lappend TheClonedSons [DataSet clone $Son]
}
return $TheClonedSons
}
if {[string equal $Action "clone"]} {
set Value [DataSet value $Elem]
set Links [DataSet links $Elem]
set Clone [DataSet create $Value]
DataSet links $Clone [DataSet clonedSonsOf $Elem]
return $Clone
}
if {[string equal $Val "GetStoredValue"]} {
return [set DataSet($Elem,$Action)]
}
if {[string equal $Action "value" ]} {
set DataSet($Elem,value) $Val
return $Val
}
if {[string equal $Action "links"]} {
set DataSet($Elem,links) $Val
return $Val
}
if {[string equal $Action "father"]} {
set DataSet($Elem,$Action) $Val
set DoIt 1
foreach Son [DataSet links $Val] {
if {$Son==$Elem} { set DoIt 0 ; break }
}
if {$DoIt} { DataSet linksappend $Val $Elem }
return $Val
}
if {[string equal $Action "linksappend"]} {
lappend DataSet($Elem,links) $Val
return [set DataSet($Elem,links)]
}
if {[string equal $Action "linkremove"]} {
set TheOthers {}
foreach Son [DataSet links $Elem] {
if {$Son == $Val} { continue }
lappend TheOthers $Son
}
set DataSet($Elem,links) $TheOthers
return $TheOthers
}
}
proc TesteGrave {} {
global NomDuFichierPierre
set NomDuFichierPierre "pierre.testegrave"
File delete -force $NomDuFichierPierre
set L {6 8 9 7 }
Grave L
set A(toto) [list 4 5 "bonjour madame" [list comment va votre mari "Jules Dupont"]]
set A(tutu) 5
set A(lili) $L
Grave A
EspionneL [array get A]
unset A
Degrave A
unset L
Degrave L
Espionne $L
EspionneL [array get A]
exit
}
proc ArbreDesClasses {} {
Degrave T
NicePrintOfTree $T
exit
if {[]} {}
}
proc TestTree {Nom {Type "Access"}} {
global RepertoireDuGenome
set A [ArbreEnListe [ContenuDuFichier "$RepertoireDuGenome/phylos/$Nom"]]
puts $A
set T [TreeFromArbre "Racine" $A $Type]
NicePrintOfTree $T
set P [PathToNode N_00006 $T "value"]
set N [lindex $P end]
puts $P
set S [SwapRoot $T $N $P]
puts " et le meme en N_00006"
NicePrintOfTree $S
exit
}
proc TreeFromArbre {Valeur Arbre {Type "Classe"}} {
global NumeroPourTreeFromArbre
if { ! [info exists NumeroPourTreeFromArbre]} {
set NumeroPourTreeFromArbre 0
}
incr NumeroPourTreeFromArbre
set Beau [format "N_%5.5d" $NumeroPourTreeFromArbre]
set Valeur $Beau
if {[EstUneFeuille $Arbre]} {
set Access [NomDeLaFeuille $Arbre]
if {$Type=="Access"} { set Info $Access }
if {$Type=="Organisme"} { set Info [OrgaDuAccess $Access] }
if {$Type=="Classe"} { set Info [OCduOS [OrgaDuAccess $Access]] }
# set L [NewLeaf [list $Valeur $Info]]
set L [NewLeaf $Info]
return $L
}
Dedouble $Arbre G x D y
# set T [NewTreeFromTrees [list $Valeur ""] [TreeFromArbre $x $G $Type] [TreeFromArbre $y $D $Type]]
set T [NewTreeFromTrees $Valeur [TreeFromArbre $x $G $Type] [TreeFromArbre $y $D $Type]]
return $T
}
proc NewTree {Value BranchList} {
return [DataSet create $Value $BranchList]
}
proc NewTreeFromTrees {Value args} {
set BranchList {}
foreach Branch $args {
lappend BranchList $Branch
}
return [NewTree $Value $BranchList]
}
proc ChangeValueTree {Tree Value} {
return [DataSet value $Tree $Value]
}
proc ValueOfTree Tree {
return [DataSet value $Tree]
}
proc Branches Tree {
return [DataSet links $Tree]
}
proc NewLeaf Value {
return [NewTree $Value {}]
}
proc IsLeaf Tree {
return [DataSet isLeaf $Tree]
}
proc HasBranches Tree {
return [DataSet hasBranches $Tree]
}
proc HeightOfTree Tree {
if {[IsLeaf $Tree]} { return 1 }
set Highest 0
foreach B [Branches $Tree] {
set H [HeightOfTree $B]
if {$H>$Highest} { set Highest $H }
}
return [incr Highest]
}
proc CutBranch {Tree {IndexOrNode end}} {
set Branches [Branches $Tree]
if {[regexp {^[0-9]+$} $IndexOrNode] && [string length $IndexOrNode]>5 } {
set Index [lsearch $Branches $IndexOrNode]
} else {
set Index $IndexOrNode
}
set NewBranches [lreplace $Branches $Index $Index]
return [NewTree [ValueOfTree $Tree] $NewBranches]
}
proc AddBranch {B Tree {Index end}} {
set NewBranches [linsert [Branches $Tree] $Index $B]
return [NewTree [ValueOfTree $Tree] $NewBranches]
}
proc AddLeaf {Value Tree {Index end}} {
return [AddBranch [NewLeaf $Value] $Tree $Index]
}
proc NicePrintOfTree {Tree {Indent 0}} {
set Indentation [string repeat " " $Indent]
puts "$Indentation [ValueOfTree $Tree]"
incr Indent
foreach B [Branches $Tree] {
NicePrintOfTree $B $Indent
}
}
proc GardePierre {} {
global CanalPierre NomDuFichierPierre
ClosPierre
if { [file exists $NomDuFichierPierre] } {
if {[Garde $NomDuFichierPierre]==""} {
FaireLire "I Couldn't make a backup of $NomDuFichierPierre"
}
File delete -force $NomDuFichierPierre
}
}
proc ClosPierre {} {
global CanalPierre NomDuFichierPierre
if { [info exists CanalPierre] } {
close $CanalPierre
unset CanalPierre
}
}
proc AppendPierre {} {
global CanalPierre NomDuFichierPierre
if { [info exists CanalPierre] } {
ClosPierre
}
if { ! [info exists NomDuFichierPierre] } {
set NomDuFichierPierre "pierre"
}
set CanalPierre [open $NomDuFichierPierre a]
return $CanalPierre
}
proc ReOuvrePierre {} {
global CanalPierre NomDuFichierPierre
if { [info exists CanalPierre] } {
ClosPierre
}
if { ! [info exists NomDuFichierPierre] } {
set NomDuFichierPierre "pierre"
}
if { ! [file exists $NomDuFichierPierre]} { return "" }
set CanalPierre [open $NomDuFichierPierre r]
return $CanalPierre
}
proc Grave VariableDeGrave {
upvar $VariableDeGrave ContenuVariableDeGrave
set Pierre [AppendPierre]
puts $Pierre ""
puts $Pierre "#Debut $VariableDeGrave"
set lElements [uplevel "array names $VariableDeGrave"]
if {[llength $lElements]==0} {
puts $Pierre "set $VariableDeGrave [list $ContenuVariableDeGrave]"
} else {
foreach e $lElements {
puts $Pierre "set $VariableDeGrave\($e\) [list $ContenuVariableDeGrave($e)]"
}
}
puts $Pierre "#Fin $VariableDeGrave"
}
proc Degrave VariableDeGrave {
upvar $VariableDeGrave $VariableDeGrave
# upvar $VariableDeGrave ContenuVariableDeGrave (pourquoi ai-je mis cette ligne ?)
set lElements [uplevel "array names $VariableDeGrave"]
if {[llength $lElements]==0} {
set Pierre [ReOuvrePierre]
if {$Pierre==""} { return "" }
set OnYest 0
while { [gets $Pierre entree]>=0 } {
if { [regexp "#Debut $VariableDeGrave" $entree] } {
set OnYest 1
gets $Pierre entree
}
if { [regexp "#Fin $VariableDeGrave" $entree] } { break }
if { $OnYest } { eval $entree }
}
} else {
}
return $VariableDeGrave
}
proc Graphiste {LesOrdresPourGIF ValWidth ValHeight X1 Y1 X2 Y2 CheminGIF {OnVeutLeTexte 1} {OnVeutLesArcs 1}} {
global CommandeCanvart
global GraphisteDir
set ValWidth [expr int($ValWidth)]
set ValHeight [expr int($ValHeight)]
set RepertoireLog ""
if {[info exists GraphisteDir]} {
set RepertoireLog "$GraphisteDir/log"
}
if {$RepertoireLog=="" || ! [file writable $RepertoireLog]} {
set RepertoireLog "[RepertoireDeTravail]/log"
}
if { ![file exists $RepertoireLog] } {
file mkdir $RepertoireLog
}
if {[regexp "/gd" $CommandeCanvart]} {
set OrdrePourGIF [string trim [join $LesOrdresPourGIF "\n"]]
set f [open "|$CommandeCanvart $ValWidth $ValHeight \
$X1 $Y1 $X2 $Y2 \
$CheminGIF $OnVeutLeTexte 2>/dev/null" "w"]
puts $f $OrdrePourGIF
flush $f
close $f
return "OK"
}
if {[regexp "^java" $CommandeCanvart]} {
if {$OnVeutLeTexte} { set TexteOuNon "yes" } else { set TexteOuNon "no" }
if {$OnVeutLesArcs} { set ArcsOuNon "yes" } else { set ArcsOuNon "no" }
set AvecLog 1
if {$AvecLog} {
set fico [open "$RepertoireLog/entreecanvart.log" "w"]
puts $fico [string trim [join $LesOrdresPourGIF "\n"]]
close $fico
}
set f [open "|$CommandeCanvart \
-width $ValWidth -height $ValHeight \
-box $X1 $Y1 $X2 $Y2 \
-output $CheminGIF -nodecompose -text $TexteOuNon -arc $ArcsOuNon \
>& $RepertoireLog/sortiecanvart.log" "w"]
puts $f [string trim [join $LesOrdresPourGIF "\n"]]
flush $f
close $f
return "OK"
}
}
proc FichierTFAsNonRedondant {FichierTFAs {NouveauFichier ""}} {
if {$NouveauFichier==""} { set NouveauFichier $FichierTFAs }
foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "@"] {
if {[regexp "@" $Access]} { continue }
Espionne $Access
lappend LeNouveau [LaSequenceDuTFAs $FichierTFAs $Access]
}
return [SauveLesLignes $LeNouveau dans $NouveauFichier]
}
proc C28 {I} {
set L {
{
aab, aac, aad, bab, bac, bad, bbc, bbd, cab, cac, cad, cbc, cbd, ccd, dab, dac, dad, dbc, dbd, dcd
}
{
aab, aac, aad, bab, bac, bad, bbc, bbd, cab, cac, cad, cbc, cbd, ccd, dab, dac, dad, dbc, dbd, ddc
}
{
aab, aac, aad, bab, bac, bad, bbc, bbd, cab, cac, cad, cbc, cbd, cdb, cdc, dab, dac, dad, ddb, ddc
}
{
aab, aac, aad, bab, bac, bad, bbc, bbd, cab, cac, cad, cbc, cbd, cdc, cdd, dab, dac, dad, dbc, dbd
}
{
aab, aac, aad, bab, bac, bad, bbc, bbd, cab, cac, cad, cbc, cbd, cdd, dab, dac, dad, dbc, dbd, dcc
}
{
aab, aac, aad, bab, bac, bad, bbc, bda, bdb, bdc, cab, cac, cad, cbc, cda, cdb, cdc, dda, ddb, ddc
}
{
aab, aac, aad, bab, bac, bad, bbc, bda, bdb, bdc, cab, cac, cad, ccb, cda, cdb, cdc, dda, ddb, ddc
}
{
aab, aac, aad, bab, bac, bad, bbc, bdb, bdc, bdd, cab, cac, cad, cbc, cdb, cdc, cdd, dab, dac, dad
}
{
aab, aac, aad, bab, bac, bad, bbc, bdb, bdc, bdd, cab, cac, cad, ccb, cdb, cdc, cdd, dab, dac, dad
}
{
aab, aac, aad, bab, bac, bad, bca, bcb, bcd, bdb, bdd, cca, ccb, ccd, dab, dac, dad, dca, dcb, dcd
}
{
aab, aac, aad, bab, bac, bad, bca, bcb, bcd, bdd, cca, ccb, ccd, dab, dac, dad, dbb, dca, dcb, dcd
}
{
aab, aac, aad, bab, bac, bad, bcb, bcc, bcd, bdb, bdd, cab, cac, cad, dab, dac, dad, dcb, dcc, dcd
}
{
aab, aac, aad, bab, bac, bad, bcb, bcc, bcd, bdd, cab, cac, cad, dab, dac, dad, dbb, dcb, dcc, dcd
}
{
aab, aac, aad, bab, bac, bad, bcb, bcc, bdb, bdd, cab, cac, cad, cdb, cdd, dab, dac, dad, dcb, dcc
}
{
aab, aac, ada, adb, adc, add, bab, bac, bbc, bda, bdb, bdc, bdd, cab, cac, cbc, cda, cdb, cdc, cdd
}
{
aab, aac, ada, adb, adc, add, bab, bac, bbc, bda, bdb, bdc, bdd, cab, cac, ccb, cda, cdb, cdc, cdd
}
{
aab, aac, ada, adb, adc, add, bab, bac, bca, bcb, bda, bdb, bdc, bdd, cca, ccb, cda, cdb, cdc, cdd
}
{
aab, aac, ada, adb, adc, add, bab, bac, bcb, bcc, bda, bdb, bdc, bdd, cab, cac, cda, cdb, cdc, cdd
}
{
aab, aac, ada, adb, adc, add, bab, bac, bcc, bda, bdb, bdc, bdd, cab, cac, cbb, cda, cdb, cdc, cdd
}
{
aab, aca, acb, acc, acd, ada, adb, add, bab, bca, bcb, bcc, bcd, bda, bdb, bdd, dca, dcb, dcc, dcd
}
{
aab, aca, acb, acc, acd, ada, adb, add, bba, bca, bcb, bcc, bcd, bda, bdb, bdd, dca, dcb, dcc, dcd
}
{
aab, aca, acb, acc, ada, adb, add, bab, bca, bcb, bcc, bda, bdb, bdd, cda, cdb, cdd, dca, dcb, dcc
}
{
aab, aca, acb, acc, ada, adb, add, bba, bca, bcb, bcc, bda, bdb, bdd, cda, cdb, cdd, dca, dcb, dcc
}
{
aba, abb, abc, abd, aca, acc, acd, ada, add, cba, cbb, cbc, cbd, dba, dbb, dbc, dbd, dca, dcc, dcd
}
{
aba, abb, abc, abd, aca, acc, acd, add, cba, cbb, cbc, cbd, daa, dba, dbb, dbc, dbd, dca, dcc, dcd
}
{
aba, abb, abc, abd, aca, acc, ada, add, cba, cbb, cbc, cbd, cda, cdd, dba, dbb, dbc, dbd, dca, dcc
}
{
aba, abb, abc, aca, acc, ada, adc, add, bda, bdc, bdd, cba, cbb, cbc, cda, cdc, cdd, dba, dbb, dbc
}
{
aba, abb, abc, acc, ada, adc, add, bda, bdc, bdd, caa, cba, cbb, cbc, cda, cdc, cdd, dba, dbb, dbc
}
}
set i 0
foreach l $L {
regsub -all {[^abcd,]} $l "" l
regsub -all a $l A l
regsub -all b $l C l
regsub -all c $l G l
regsub -all d $l T l
Espionne
Espionne $l
set X($i) [split $l ","]
DiBase $X($i)
incr i
}
exit
return $X($I)
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.