#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
#
set xml "\"
0headorg.pdb.query.simple.EnzymeClassificationQueryEnzyme Classification Search : EC=6.1.1.*6.1.1.*1andheadorg.pdb.query.simple.ExpTypeQueryExperimental Method is X-RAYX-RAY\""
set xml "
B0907org.pdb.query.simple.ExpTypeQueryExperimental Method Search : Experimental Method=SOLID-STATE NMRSOLID-STATE NMR"
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 ""
lappend LeXml " "
lappend LeXml " null"
lappend LeXml " "
lappend LeXml " "
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 " "
lappend LeXml " $Dir/$B"
lappend LeXml " "
lappend LeXml " "
}
lappend LeXml ""
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 ""
puts $CanalJavOO "123"
puts $CanalJavOO "$Resource"
puts $CanalJavOO "$Query"
puts $CanalJavOO ""
puts $CanalJavOO ""
flush $CanalJavOO
Espionne $Query
set LaReponse {}
while {[gets $CanalJavOO Ligne]>=0} {
if {[regexp "" $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 "
$Reponse
" }
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 ""
lappend LeHtml "