Index by: file name |
procedure name |
procedure call |
annotation
gscope_specific.tcl
(annotations | original source)
#rR gscope_specific.tcl to some Gscope projects
proc CreateGscopeProjectGAL4 {} {
set RepGAL4 "/genomics/link/GAL4"
set N 0
set Prefixe "GAL"
NousAllonsAuBoulot $RepGAL4
file mkdir beton
file mkdir fiches
file mkdir prottfa
file mkdir infos
foreach Fictfa [lsort [glob -nocomplain "query_fasta/*.fasta"]] {
incr N
set Queue [file tail $Fictfa]
regsub ".fasta" $Queue "" Id
regsub "_YEAST" $Id "" Gn
set FicPsiblast "psiblastJulie/$Queue.psiblast"
set Nom [format "%s%2.2d" $Prefixe $N]
set Tfa [ContenuDuFichier $Fictfa]
set Entete [EnteteDuTexteTFA $Tfa]
set Seq [QueLaSequenceDuTexteTFA $Tfa]
Espionne $Entete
Espionne $Seq
lassign [split $Entete "|"] Sp Access Id
lassign [split [GeneQuid UniprotData $Access "QY,AC,ID,GN,DE"] "\n"] Q A I G D
regsub ";.*$" $A "" A
regsub " .*$" $I "" I
if {[regexp {Name=([^\;]+)} $G Match X]} { set G $X }
if {[regexp {Full=([^\;]+);$} $D Match X]} { set D $X }
Espionne $Q \n $A \n $I \n G=$G \n D=$D
if {$Gn!=$G} { FaireLire "$Nom $Gn!=$G" }
set NewEntete "$Nom $A $I $G $D"
set NewTfa [SequenceFormatTFA $Seq $NewEntete "protbrut"]
Espionne Sauve $NewTfa dans "prottfa/$Nom"
Espionne file copy $FicPsiblast "psiblast/$Nom"
}
OnRevientDuBoulot
}
proc InformeAliasWithACIfNotGNPourTous {MauvaisAlias MauvaisGN} {
#rR Si l'actuel Alias contient $MauvaisAlias on prend GN sauf s'il contient MauvaisGN, par defaut on prond AC
foreach Nom [ListeDesPABs] {
set Entete [EnteteDuFichierTFA [GscopeFile $Nom prottfa]]
set Alias [ExtraitInfo $Nom Alias]
if {[regexp $MauvaisAlias $Alias]} {
set Alias [ExtraitInfo $Nom "GN:"]
}
if {[regexp $MauvaisGN $Alias]} {
set Alias [ExtraitInfo $Nom "AC:"]
}
Espionne "$Nom $Alias"
InformeSansDemander $Nom "=Alias: $Alias"
}
}
proc InformeDEFromProttfaPourTous {} {
#rR On traite ici le cas >Nom BID AC DE1 DE2 DE3 DEi OS=
#rR et non pas le cas >Nom BID AC Genre Espesce DE1 DE2 DE3 DEi
foreach Nom [ListeDesPABs] {
set Entete [EnteteDuFichierTFA [GscopeFile $Nom prottfa]]
set DE [lrange [split $Entete " "] 3 end]
if {[set iOS [string first "OS=" $DE]]>=0} {
set DE [string range $DE 0 $iOS-1]
}
set DE [string trim $DE]
Espionne "$Nom $DE"
# FaireLire "$Nom $DE"
if {$DE==""} {
InformeParSuppressionDuChamp $Nom "DE:"
} else {
InformeSansDemander $Nom "=DE: $DE"
}
}
}
proc InformeDESansOSPourTous {} {
foreach Nom [ListeDesPABs] {
set DE [ExtraitInfo $Nom "DE:"]
if {[set iOS [string first "OS=" $DE]]>=0} {
set DE [string trim [string range $DE 0 $iOS-1]]
Espionne "$Nom $DE"
if {$DE==""} {
InformeParSuppressionDuChamp $Nom "DE:"
} else {
InformeSansDemander $Nom "=DE: $DE"
}
}
}
}
proc QfO_Wup {} {
#rR QfO
#rR Quest for Orthologs http://www.ebi.ac.uk/reference_proteomes
#rR C'est un site qui fournit de beaux proteomes complets avec les proteines de référence, sans tous les variants ... :)
#rR Voici la procédure manuelle
#rR cd QfO_Dir
#rR ramener ftp://ftp.ebi.ac.uk/pub/databases/reference_proteomes/QfO/QfO_release_2015_04.tar.gz
#rR gunzip QfO_release_2015_04.tar
#rR gscope CreateProteomesWithOX
#rR gscope QfO_CreateBlastbase
#rR C'est tout :)
}
proc QfO_Dir {} {
return "/genomics/link/QfO"
}
proc QfO_ProteomesDir {} {
return "/genomics/link/QfO/proteomes"
}
proc QfO_BlastbaseDir {} {
return "/genomics/link/QfO/blastbase"
}
proc QfO_CreateBlastbase {} {
set BlastbaseDir [QfO_BlastbaseDir]
file mkdir $BlastbaseDir
NousAllonsAuBoulot $BlastbaseDir
exec cat [QfO_ProteomesDir]/* > QfO
/biolo/blast/bin/makeblastdb -in QfO -out QfO -hash_index -parse_seqids -dbtype prot
file rename formatdb.log QfO.formatdb.log
OnRevientDuBoulot
return "$BlastbaseDir/Qfo"
}
proc QfO_CreateProteomesWithOX {} {
set LesNouveaux {}
set ProteomesDir [QfO_ProteomesDir]
file mkdir $ProteomesDir
foreach TaxId [QfO ListOf TaxId] {
set OX $TaxId
set OS [QfO $TaxId OS]
set FastaFile [QfO $TaxId Fasta]
Espionne $FastaFile
set Queue [file tail $FastaFile]
set TfasFile "$ProteomesDir/${OS}_$OX"
set LeTfas {}
foreach Ligne [LesLignesDuFichier $FastaFile] {
if {[regexp ">" $Ligne]} { append Ligne " OX=$OX" }
lappend LeTfas $Ligne
}
Espionne $TfasFile
lappend LesNouveaux [SauveLesLignes $LeTfas dans $TfasFile]
}
return $LesNouveaux
}
proc QfO {{Qui ""} {Quoi ""}} {
global QfO
if {[info exists QfO($Qui,$Quoi)]} { return $QfO($Qui,$Quoi) }
if {[info exists QfO("EstCharge")]} {
if {[info exists QfO($Qui,TaxId)]} {
set TaxId $QfO($Qui,TaxId)
if {[info exists QfO($TaxId,$Quoi)]} { return $QfO($TaxId,$Quoi) }
}
return ""
}
set QfO("EstCharge") 1
set QfO(FileName,) "[QfO_Dir]/README"
foreach F [lsort [glob "[QfO_Dir]/*/*"]] {
set Queue [file tail $F]
if { ! [regexp {^[^_]+_([0-9]+)\.fasta$} $Queue Match OX] } { continue }
set QfO($OX,Fasta) $F
lappend QfO(ListOf,Fasta) $F
}
set OnAttendProteomeID 1
set OnEstDansProteomeID 0
foreach Ligne [LesLignesDuFichier $QfO(FileName,)] {
if {$OnAttendProteomeID} {
if { ! [regexp {^Proteome_ID Tax_ID} $Ligne] } { continue }
set OnAttendProteomeID 0
set OnEstDansProteomeID 1
continue
}
if {$OnEstDansProteomeID && [string trim $Ligne]==""} { break }
set LesMots [LesMotsDeLaLigne $Ligne]
lassign $LesMots ProteomeId TaxId OsCode NbProt NbAdd
set SpeciesName [join [lrange $LesMots 6 end] " "]
scan $SpeciesName "%s %s" G E
set OS "${G}_$E"
set Fasta $QfO($TaxId,Fasta)
set QfO($TaxId,ProteomeId) $ProteomeId
set QfO($TaxId,OsCode) $OsCode
set QfO($TaxId,NbProt) $NbProt
set QfO($TaxId,NbAdd) $NbAdd
set QfO($TaxId,SpeciesName) $SpeciesName
set QfO($TaxId,OS) $OS
set QfO($ProteomeId,TaxId) $TaxId
set QfO($TaxId,TaxId) $TaxId
set QfO($OsCode,TaxId) $TaxId
set QfO($SpeciesName,TaxId) $TaxId
set QfO($OS,TaxId) $TaxId
set QfO($Fasta,TaxId) $TaxId
lappend QfO(ListOf,TaxId) $TaxId
lappend QfO(ListOf,ProteomeId) $ProteomeId
lappend QfO(ListOf,SpeciesName) $SpeciesName
lappend QfO(ListOf,OS) $OS
lappend QfO(ListOf,NbProt) $NbProt
lappend QfO(ListOf,NbAdd) $NbAdd
incr QfO(NumberOf,Proteins) $NbProt
}
return [QfO $Qui $Quoi]
}
#rR QfO fin
#rR BalibaseCreateBlastDatabase
proc BalibaseCreateBlastDatabase {} {
foreach Nom [ListeDesPABs] {
set FichierTFAs [GscopeFile $Nom "tfas"]
foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
regsub ">$Access" $TFA ">${Nom}_$Access" New
lappend LesNew $New
}
}
return [SauveLesLignes $LesNew dans "[RepertoireDuGenome]/banques/BalibaseAllProt"]
}
proc BalibaseCorrectLink {} {
if {1} {
cd [RepertoireDuGenome]
cd "tfas"
foreach RV [glob "../RV*"] {
Espionne $RV
foreach P [glob -nocomplain "$RV/*.tfa"] {
set F [file tail $P]
regsub {\..*} $F "" Nom
Espionne "ln -sf $P $Nom"
exec ln -sf $P $Nom
}
}
}
if {1} {
cd [RepertoireDuGenome]
cd "msf"
foreach RV [glob "../RV*"] {
Espionne $RV
foreach P [glob -nocomplain "$RV/*.msf"] {
set F [file tail $P]
regsub {\..*} $F "" Nom
Espionne "ln -sf $P $Nom"
exec ln -sf $P $Nom
}
}
}
}
proc CanvaPuzz {} {
set K [UnCanva 100 100 300 400]
$K create rectangle 10 10 30 40 -fill "red" -outline "black"
$K create line 5 20 45 20 -fill "blue"
}
proc NormaliseBanqueBlast {Source {Destin ""}} {
if {$Destin==""} { set Destin "$Source.normalise" }
set LeNew {}
set i 0
foreach Ligne [LesLignesDuFichier $Source] {
if { [string index $Ligne 0] ne ">"} { lappend LeNew $Ligne; continue }
scan $Ligne "%s" sba
set D [string length $sba]
incr D
lassign [split $sba "|"] s a b
set S "SPT" ; if {$s eq ">sp"} { set S "SW" }
set N "$S:$b $a"
set R [string range $Ligne $D end]
set TOS ""
if {[regexp {OS=([^ ]+ [^ ]+) } $Ligne Match OS]} { set TOS "$OS " }
set New ">$N $TOS$R"
lappend LeNew $New
if {[incr i]%1000==0} { Espionne $i }
}
SauveLesLignes $LeNew dans $Destin
}
proc TTLLrenomme {} {
set Fic "/genomics/link/TTLL/DeYann/ttll_seq_fasta.txt"
foreach Access
}
proc PatternSearchInGenome {} {
set Url "http://kilida.u-strasbg.fr:8086/CST_Java_Servlet/InterfaceWebCST?action=search&genome=human_2006-nomasque&get=result&pattern=ATGATGATGATGATGATGA"
return [ContenuDuFichier $Url]
}
proc SauvePuzzleFit {Texte dans Fichier} {
if {[OuiOuNonMemo "Do I overwrite" 0] && [FileExists $Fichier]} { return ""}
return [Sauve $Texte dans $Fichier]
}
proc ClonePuzzleFit {{OrgaCible ""} {PrefixeCible ""} {Destin ""}} {
#rR il faut etre dans l'ancien pour creer le nouveua
#rR Cree un nouveau projet Gscope en copiant tous les fichiers en y changeant les noms
if {$Destin==""} { set Destin "PFyeastTFIID" }
set RepDestin $Destin
if { ! [regexp "/" $RepDestin]} { set RepDestin "/genomics/link/$Destin" }
if {$OrgaCible==""} { set OrgaCible "Saccharomyces cerevisiae" }
if {$PrefixeCible==""} { set PrefixeCible "PUY" }
if {[NotreOS]==$OrgaCible || [PreFixe]=="$PrefixeCible"} {
FaireLire "Attention il ne faut pas etre dans le projet Cible !!!\n \
[NotreOS] [PreFixe] ==> $OrgaCible $PrefixeCible"
exit
}
set Prefixe [PreFixe]
foreach Nom [ListeDesPABs] {
set GN [ValiGN $Nom]
set AC [ExtraitInfo $Nom "AC:"]
set AcDuPuz($Nom) $AC
set FicTFAs [GscopeFile $Nom "tfasdescopains"]
set LesHomo {}
set Homo ""
foreach Access [LaSequenceDuTFAs $FicTFAs "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $FicTFAs $Access]
set Entete [EnteteDuTexteTFA $TFA]
regsub "^>" $Entete "" Entete
set B "" ; set G "" ; set E ""
scan $Entete "%s %s %s %s" A B G E
if { ! [string equal -nocase $OrgaCible "$G $E"]} { continue }
lappend LesHomo $A
}
if {[llength $LesHomo]==0} { set Homo ""; FaireLire "No homologue for $Nom $GN $AC" }
if {[llength $LesHomo]==1} { set Homo [lindex $LesHomo 0] }
if {[llength $LesHomo]>=2} {
# FaireLire "More than 1 homologue for $Nom $GN $AC, please select the good one"
if {[OuiOuNonMemo "Do I always use the first access"]} {
set Homo [lindex $LesHomo 0]
} else {
set Homo [ChoixParmi $LesHomo]
}
}
if {$Homo==""} { continue }
if {[info exists DejaVu($Homo)]} {
# FaireLire "Handling $Homo in $Nom $GN $AC \n I saw already $DejaVu($Homo)"
continue
}
regsub $Prefixe $Nom $PrefixeCible New
set Message "$New $Homo $Nom $GN $AC"
set EstBon($Nom) 1
lappend LesBonsHomo $Message
set DejaVu($Homo) $Message
Espionne $Message
}
set LesNouvellesBornes {}
foreach Ligne [LesLignesDuFichier "[Fiches]/bornesdespabs"] {
scan $Ligne "%s" Nom
if { ! [info exists EstBon($Nom)]} { continue }
regsub $Prefixe $Ligne $PrefixeCible Borne
lappend LesNouvellesBornes $Borne
}
file mkdir "$RepDestin/fiches"
SauvePuzzleFit [join $LesNouvellesBornes "\n"] dans "$RepDestin/fiches/bornesdespabs"
set Beton [ContenuDuFichier "[RepertoireDuGenome]/beton/miniconfig"]
regsub "PrefixeDesORFs $Prefixe" $Beton "PrefixeDesORFs $PrefixeCible" Beton
regsub {NotreOS [^\n]+} $Beton "NotreOS $OrgaCible" Beton
set Classe [OCduOS $OrgaCible]
regsub {NotreOC [^\n]+} $Beton "NotreOC $Classe" Beton
file mkdir "$RepDestin/beton"
SauvePuzzleFit $Beton dans "$RepDestin/beton/miniconfig"
file mkdir "$RepDestin/prottfa"
file mkdir "$RepDestin/protembl"
file mkdir "$RepDestin/infos"
file mkdir "$RepDestin/tfasdescopains"
file mkdir "$RepDestin/msf"
file mkdir "$RepDestin/msfleon"
file mkdir "$RepDestin/macsimXml"
file mkdir "$RepDestin/pdb"
foreach Ligne $LesBonsHomo {
Espionne $Ligne
scan $Ligne "%s %s %s %s %s" New Homo Nom GNh ACh
set FicProttfa "$RepDestin/prottfa/$New"
set FicProtEmbl "$RepDestin/protembl/$New"
set FicInfo "$RepDestin/infos/$New"
set FicTFAs "$RepDestin/tfasdescopains/$New"
set FicMSF "$RepDestin/msf/$New"
set FicLEON "$RepDestin/msfleon/$New"
set FicMacsims "$RepDestin/macsimXml/$New"
set FicPDB "$RepDestin/pdb/$New"
set LeEmbl [LaSequenceDesBanques $Homo]
set Embl [join $LeEmbl "\n"]
SauvePuzzleFit $Embl dans $FicProtEmbl
DecortiqueLesLignesEMBL $LeEmbl ID AC DE GN OS OC OX
set DE [VraiDEDeLaLigneDE $DE]
set Linfo {}
lappend Linfo "Nom: $New"
lappend Linfo "ID: $ID"
lappend Linfo "AC: $AC"
lappend Linfo "DE: $DE"
lappend Linfo "OS: $OS"
lappend Linfo "OC: $OC"
lappend Linfo "OX: $OX"
lappend Linfo "ValiGN: $GN"
set Info [join $Linfo "\n"]
SauvePuzzleFit $Info dans $FicInfo
set Entete ">$New $OrgaCible $AC $DE"
set TFA [SequenceFormatTFA [join $LeEmbl "\n"] $Entete "protembl"]
SauvePuzzleFit $TFA dans $FicProttfa
set TFAs [ContenuDuFichier [GscopeFile $Nom "tfasdescopains"]]
regsub ">$Nom " $TFAs ">$ACh " TFAs
regsub ">$Homo " $TFAs ">$New " TFAs
foreach Puz [ListeDesPABs] {
set A $AcDuPuz($Puz)
regsub -all "$Puz" $TFAs "$A" TFAs
}
SauvePuzzleFit $TFAs dans $FicTFAs
set FicMacSource [GscopeFile "$Nom.org.aj" "macsimXml"]
if {[FileAbsent $FicMacSource]} { set FicMacSource [GscopeFile "$Nom.org" "macsimXml"] }
if {[FileAbsent $FicMacSource]} { set FicMacSource [GscopeFile "$Nom" "macsimXml"] }
set Mac [ContenuDuFichier $FicMacSource]
regsub -all "$Nom" $Mac "$ACh" Mac
regsub -all "$Homo" $Mac "$New" Mac
set RE "<seq-name>${New}_\[^<\]+</seq-name>"
regsub -all $RE $Mac "<seq-name>$New</seq-name>" Mac
foreach Puz [ListeDesPABs] {
set A $AcDuPuz($Puz)
regsub -all "$Puz" $Mac "$A" Mac
}
SauvePuzzleFit $Mac dans $FicMacsims
set SourcePDB [GscopeFile $Nom "pdb"]
if {[file exists $SourcePDB]} { file copy $SourcePDB $FicPDB }
}
return $LesBonsHomo
}
proc MacsimsSpliRetPourNaomi {{Compress ""}} {
set Compress [regexp -nocase "^Comp" $Compress]
set SourceDir "[RepertoireDuGenome]/macsimXml"
if {$Compress} {
set DestinDir "[RepertoireDuGenome]/macsimXmlPourNaomiGZ"
} else {
set DestinDir "[RepertoireDuGenome]/macsimXmlPourNaomi"
}
file mkdir $DestinDir
set I 1
foreach Nom [ListeDesPABs] {
if {[incr I -1]==0} { Espionne $Nom; set I 100 }
set Clus [ExtraitInfo $Nom "Cluster"]
set Fic "$SourceDir/$Nom.orgord.aj"
if {[FileAbsent $Fic]} { set Fic "$SourceDir/$Nom.orgord" }
if {[FileAbsent $Fic]} { continue }
if {$Compress} {
set Out "$DestinDir/$Nom-$Clus.xml.gz"
exec gzip -c $Fic > $Out
} else {
set Out "$DestinDir/$Nom-$Clus.xml"
file copy $Fic $Out
}
}
}
proc MontagePhoto {{Ordre ""} {DirImages ""} {DirImagettes ""} {LargeurImagette ""} {HauteurImagette ""} {GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "Display" }
if {$LargeurImagette=="" && $HauteurImagette==""} { set LargeurImagette 400 }
if {$DirImages==""} { set DirImages "/home/moumou/synmito/3Data/Figures" }
if {$DirImagettes==""} {
if {$Ordre!=""} {
set DirImagettes "$DirImages/$Ordre"
} else {
set DirImagettes "$DirImages/Imagettes"
}
}
cd $DirImages
set LesImagesNonTriees [glob -nocomplain "*.png"]
foreach Image $LesImagesNonTriees {
regsub {\.[^\.]+$} $Image "" U
set MonImage($U) $Image
}
if {$Ordre==""} {
set LesImages $LesImagesNonTriees
} else {
set LesImages {}
foreach U [split $Ordre ""] c [split "[string range $Ordre 1 end]Z" ""] {
if {[regexp {[a-z]} $U]} { continue }
if {[regexp {[a-z]} $c]} { set U "$U$c" }
if {[info exists MonImage($U)]} {
lappend LesImages $MonImage($U)
} else {
lappend LesImages "NULL:"
}
}
}
if {[FileAbsent $DirImagettes]} { file mkdir $DirImagettes }
set LesImagettes {}
foreach Image $LesImages {
set Imagette $DirImagettes/$Image
lappend LesImagettes [file tail $Imagette]
if {$Image=="NULL:"} { continue }
exec convert $Image -resize ${LargeurImagette}x${HauteurImagette} $Imagette
}
cd $DirImagettes
set Commande "montage -size 140x104 "
set LeNouvelOrdre {}
foreach Imagette $LesImagettes {
set U $Imagette
regsub -nocase {\.[^.]+$} $U "" U
set Chaine ""
if {$Imagette=="NULL:"} { append Commande " -label \"\" NULL:"; lappend LeNouvelOrdre "_"; continue }
lappend LeNouvelOrdre $U
if {[regexp {^([A-Z])([a-z])$} $U Match Useul Chaine]} {
set U $Useul
if {$Chaine=="a"} { set Chaine "alpha" }
if {$Chaine=="b"} { set Chaine "beta" }
set Chaine "$Chaine chain"
}
set T [UT $U]
set T [string totitle $T]
set RS "${T}RS $Chaine"
set Titre "$U $RS"
append Commande " -label \"$Titre\" $Imagette"
}
set NouvelOrdre [join $LeNouvelOrdre ""]
set Title "Marie fait du coloriage $DirImagettes [Date Nice]"
append Commande " -geometry +5+5 -tile 3x -frame 5 -title \"$Title\" Montage.png"
eval exec $Commande
exec convert Montage.png Montage.gif
if {$GetWhat=="Display"} {
image create photo Montage -file "Montage.gif"
set W [image width Montage]
set H [image height Montage]
set K [UnCanva $W $H $W [Mini $H 800]]
$K create image [expr $W/2] [expr $H/2] -image Montage -tags "Montage"
return $K
}
return $DirImagettes
}
proc Seraphin37Orfs {} {
foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/atelier/Seraphin/37Orfs.tfa"] {
set Ligne [string trim $Ligne]
if {[regexp {\#(.+)} $Ligne Match Orga]} { continue }
if {$Ligne==""} { continue }
if {[regexp ">" $Ligne]} {
regsub -all { +} $Ligne " " Ligne
regsub "Chr " $Ligne "Chr" Ligne
regsub " reverse complement" $Ligne "-" Ligne
scan $Ligne "%s %s" Access Id
regsub ">" $Access "" Access
if {[NomDuAlias $Access] != ""} { FaireLire "$Access est deja [NomDuAlias $Access]" }
lappend LesAccess $Access
set LaDesc {}
set Desc ""
if {$Orga=="Saccharomyces cerevisiae"} {
set Info [YeastGlossary $Id]
set InDesc 0
foreach Li [split $Info "\n"] {
if {[regexp {Description\.*\:(.+)} $Li Match D]} {
set InDesc 1
lappend LaDesc [string trim $D]
set Desc [join $LaDesc " "]
continue
}
if { ! [regexp -nocase {^[A-Z]} $Li] && $InDesc} {
set D $Li
lappend LaDesc [string trim $D]
set Desc [join $LaDesc " "]
continue
}
set InDesc 0
}
} else {
set Info [join [LaSequenceDesBanques $Id] "\n"]
foreach Li [split $Info "\n"] {
if {[regexp {^DE ([^\n]+)} $Li Match D]} {
lappend LaDesc [string trim $D]
set Desc [join $LaDesc " "]
}
}
}
regsub " " $Ligne " $Orga " Ligne
append Ligne " $Desc"
lappend LesEntetes "$Ligne"
set LeTfaDe($Access) [list $Ligne]
continue
}
lappend LeTfaDe($Access) $Ligne
}
set LesNouveaux {}
foreach Access $LesAccess {
set FichierTFA "[RepertoireDuGenome]/atelier/Seraphin/$Access.tfa"
SauveLesLignes $LeTfaDe($Access) dans $FichierTFA
lappend LesNouveaux "$Access $FichierTFA"
}
SauveLesLignes $LesNouveaux dans "[RepertoireDuGenome]/atelier/Seraphin/37Orfs.lst"
AfficheListe $LesNouveaux
AfficheListe $LesEntetes
}
proc BestInformePourBathy {} {
foreach Nom [ListeDesPABs] {
set Info [ExtraitInfo $Nom]
set OSBlastX [ExtraitInfo $Nom "OS_BlastX:"]
if {[regexp -nocase {([A-Z]+) ([a-z]+) ([a-z0-9]+)} $OSBlastX Match Genre Espece Access]} {
set LEmbl [LaSequenceDesBanques $Access]
DecortiqueLesLignesEMBL $LEmbl ID AC DE GN OS OC OX SequenceBrute LaDETotal
InformeSansDemander $Nom "BestAccess: $Access"
InformeSansDemander $Nom "BestID: $ID"
InformeSansDemander $Nom "BestAC: $AC"
InformeSansDemander $Nom "BestDE: $DE"
InformeSansDemander $Nom "BestGN: $GN"
InformeSansDemander $Nom "BestOS: $OS"
InformeSansDemander $Nom "BestOC: $OC"
InformeSansDemander $Nom "BestOX: $OX"
}
}
}
proc InformeBathy {} {
foreach Nom [ListeDesPABs] {
set Entete [EnteteDuFichierTFA [GscopeFile $Nom nuctfa]]
set Description [StringSuivant " " dasn $Entete]
# InformeSansDemander $Nom "OriginalDescription: $Description"
scan $Description "%s" Alias
InformeSansDemander $Nom "Alias: $Alias"
if {[regexp "^CL" $Alias]} {
set Reads [BathyCompositionContig $Alias "Reads"]
set Libraries [BathyCompositionContig $Alias "Libraries"]
InformeSansDemander $Nom "Reads: [join $Reads " "]"
InformeSansDemander $Nom "Libraries: [join $Libraries " "]"
}
if {[regexp "^IN0ACC" $Alias]} {
set Library ""
scan $Description "%s %s" Bidon Library
InformeSansDemander $Nom "Reads: $Alias"
InformeSansDemander $Nom "Libraries: $Library"
}
if {[regexp "^SSH" $Alias]} {
set Library ""
scan $Description "%s %s" Bidon Library
InformeSansDemander $Nom "Reads: $Alias"
InformeSansDemander $Nom "Libraries: $Library"
}
if {[regexp "^IN0ACA" $Alias]} {
set Library ""
scan $Description "%s %s" Bidon Library
InformeSansDemander $Nom "Reads: $Alias"
InformeSansDemander $Nom "Libraries: $Library"
}
}
}
proc BathyCompositionContig {{Qui ""} {Quoi ""}} {
global BCC
if {$Qui ==""} { set Qui "Show" }
if {$Quoi==""} { set Quoi "Resume" }
if {[info exists BCC($Qui,$Quoi)]} { return $BCC($Qui,$Quoi) }
if {[info exists BCC("EstCharge")]} {
if {$Qui=="Show"} { return [AfficheListe $BCC(ListOf,$Quoi)] }
if {[info exists BCC("EstCharge")]} { return "" }
}
set BCC("EstCharge") 1
set Bathy2010Dir "/genomics/link/Bathy2010"
set BCC(NameOf,Directory) $Bathy2010Dir
set LesPerdus {}
foreach Ligne [LesLignesDuFichier "$Bathy2010Dir/DeIsa/composition_contigs.txt"] {
if { ! [regexp {CL([0-9]+)Contig([0-9]+)} $Ligne CLContig CL C] } { continue }
if {[info exists BCC($CLContig,Reads)]} { FaireLire "$CLContig deja vu !"; }
set Libraries {}
set Reads {}
foreach Mot [split $Ligne " "] {
if { ! [regexp {(IN0ACC([0-9]+)([^\.]+)).SCF} $Mot Match Read I Y]} { lappend LesPerdus $Mot; continue }
set BCC($CLContig,CL) $CL
set BCC($CLContig,C) $C
lappend Reads $Read
lappend Libraries "SSH$I"
}
set Reads [lsort -dictionary -unique $Reads]
set Libraries [lsort -dictionary -unique $Libraries]
set BCC($CLContig,Reads) $Reads
set BCC($CLContig,Libraries) $Libraries
lappend LesCLContig $CLContig
}
set BCC(ListOf,CLContig) [lsort -dictionary -unique $LesCLContig]
foreach CLContig $LesCLContig {
if { ! [regexp {CL([0-9]+)Contig([0-9]+)} $CLContig Bidon CL C] } { FaireLire "couac" }
set Resume "$CLContig $CL $C : [join $Reads " "]"
set BCC($CLContig,Resume) $Resume
lappend LeResume $Resume
}
set BCC(ListOf,Resume) $LeResume
return [BathyCompositionContig $Qui $Quoi]
}
proc Bathy2010 {{Action ""}} {
if {$Action==""} { set Action "ShowGetSave" }
set FicTfaOri "[BathyCompositionContig NameOf Directory]/DeIsa/touteslesbathy.tfa"
set FicTfaNew "[BathyCompositionContig NameOf Directory]/DeIsa/Bathy2010.tfa"
set i 0
foreach Access [LaSequenceDuTFAs $FicTfaOri "LaListeDesAccess"] {
incr i
set TFA [LaSequenceDuTFAs $FicTfaOri $Access]
set Entete [string trim [EnteteDuTexteTFA $TFA]]
set Seq [QueLaSequenceDuTexteTFA $TFA]
set A ""
if {[regexp {>(CL([0-9]+)Contig([0-9]+))} $Entete Match CLContig]} {
set A $CLContig
set Reads [BathyCompositionContig $CLContig "Reads"]
set Libraries [BathyCompositionContig $CLContig "Libraries"]
set R [llength $Reads]
set L [llength $Libraries]
set E ">$A $R reads from $L libraries"
set New [SequenceFormatTFA $Seq $E "nucbrut"]
}
if {[regexp {>(IN0[A-Z]+([0-9]+)([^\.]+)).SCF} $Entete Match Nom I Y]} {
set A $Nom
set E ">$A SSH$I library $Y"
set New [SequenceFormatTFA $Seq $E "nucbrut"]
}
if {[regexp {>(SSH([0-9]+)\.([0-9]+)([^\.]+)\.ab1)} $Entete Match Nom I Y D]} {
set A "SSH$I.$Y"
set Lib "SSH$I"
if { ! [regexp {_\-_([^_]+)_([0-9\-]+)_(.+)} $D Match Z Date Id]} { FaireLire "couaccouac" }
set E ">$A $Lib library $Z $Date $Id"
set New [SequenceFormatTFA $Seq $E "nucbrut"]
}
if {[set X [regexp {>BA[0-9]+[ \t](IN0[A-Z]+([0-9]+)([^ \t]+))} $Entete Match Nom I Y]]} {
set A $Nom
set E ">$A Stress library $Y"
set New [SequenceFormatTFA $Seq $E "nucbrut"]
}
if {$A==""} {FaireLire "$Entete was not recognized"; continue }
if {[info exists DejaVu($A)]} {
Espionne "$A"
# set AutreTFA [StringSuivant " " dans $DejaVu($A)]
set AutreTFA $DejaVu($A)
if {$TFA!=$AutreTFA} { FaireLire "duplication access" }
continue
}
lappend LeNew $New
set DejaVu($A) "$TFA"
}
if {[regexp -nocase "Show" $Action]} {set Fen [AfficheListe $LeNew] }
if {[regexp -nocase "Save" $Action]} {set Fic [SauveLesLignes $LeNew dans $FicTfaNew] }
if {[regexp -nocase "GetShow" $Action]} {return $Fen }
if {[regexp -nocase "GetSave" $Action]} {return $Fic }
return ""
}
proc DispatchCluspack {} {
set Rep "."
foreach {I O} [lsort [glob "$Rep/*"]] {
set Qi [file tail $I]
set Qo [file tail $O]
regsub "\.in" $I "" R
file mkdir $R
file rename $I $R/$Qi
file rename $O $R/$Qo
}
}
proc ExchangeColumns {FilIn {FilOut ""}} {
if {$FilOut==""} {
set FileOut $FilIn
set Ext ".txt"
regexp {\.[^\.]+$} $FilOut Ext
regsub {\.[^\.]+$} $FilOut "" FilOut
append FilOut "_OK_$Ext"
}
foreach Ligne [LesLignesDuFichier $FilIn] {
if { ! [regexp {\s} $Ligne Sep]} { lappend LeOut $Ligne ; continue }
scan $Ligne "%s %s" A B
lappend LeOut "$B$Sep$A"
}
return [SauveLesLignes $LeOut dans $FilOut]
}
proc GoodAccessForHam {} {
set Fichier "all_172.tfas"
set Texte [ContenuDuFichier $Fichier]
regsub ".tfas$" $Fichier "_OK.tfas" NewFichier
regsub -all -nocase {(>[a-z0-9\-_\+]+)([\,\.]+)} $Texte {\1} BonTexte
return [Sauve $BonTexte dans $NewFichier]
}
proc Valerie {RS RD} {
cd $RS
foreach S [lsort [glob "*.img"]] {
set D "$RD/$S"
if {[file exists $D]} { continue }
file copy $S $D
Espionne $D
}
}
proc RejectScerFlo {} {
foreach Nom [ListeDesPABs] {
if {[NombreDeCopainsDansBlast $Nom]==0} { RejectIt $Nom "0 hit ParDecret" }
}
}
proc ScerFlo {} {
set Source "/genomics/link/ScerREFUNI"
if {[OuiOuNon "Do I create bornesdespabs"]} {
set LesBornes [LesLignesDuFichier "$Source/fiches/bornesdespabs.backup"]
set LesNew [LesLignesDuFichier "[RepertoireDuGenome]/DeFlo/ListeDesSCER.txt"]
set Fin [expr [llength $LesNew]-1]
foreach Ligne [lrange $LesBornes 0 $Fin] New $LesNew {
regsub {SCER[0-9]+} $Ligne $New NewLigne
lappend LesNewLigne $NewLigne
}
return [SauveLesLignes $LesNewLigne dans "[Fiches]/bornesdespabs"]
}
if {[OuiOuNon "Do I copy the files"]} {
foreach Nom [ListeDesPABs] {
foreach Rep [list prottfa protembl infos] {
set S "$Source/$Rep/$Nom"
set D "[RepertoireDuGenome]/$Rep/$Nom"
file copy $S $D
Espionne $D
}
}
}
return
}
proc GetQS {Fichier} {
set WQuery 1
set Query ""
set Sujet ""
foreach Ligne [LesLignesDuFichier $Fichier] {
if {$WQuery && ! [regexp {^Query\:} $Ligne] } { continue }
set WQuery 0
if {[regexp {^>} $Ligne]} { break }
if {[regexp {^Query\:} $Ligne]} {
scan $Ligne "%s %d %s %d" bidon D Q F
append Query $Q
continue
}
if {[regexp {^Sbjct\:} $Ligne]} {
scan $Ligne "%s %d %s %d" bidon D S F
append Sujet $S
continue
}
}
return [list $Query $Sujet]
}
proc ShowPC {Fichier} {
set QS [GetQS $Fichier]
set Q [lindex $QS 0]
set S [lindex $QS 1]
puts [PC $Q $S]
exit
}
proc TssForESRARE {} {
set Fichier "/home/gioalt/WORK-IN-PROGRESS/data/HSDRs_coordinates_input.txt"
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp {^ESRAR} $Ligne] } { continue }
scan $Ligne "%s %s %s %s %s %s %s" N Name Chr Strand Seq D F
set M [expr ($D +$F)/2]
set B [LocBefore $M "Mouse" $Chr]; scan $B "%s %s %s %s" RB DB FB SB
set A [LocAfter $M "Mouse" $Chr]; scan $A "%s %s %s %s" RA DA FA SA
set I [LocIn $M "Mouse" $Chr]; scan $I "%s %s %s %s" RI DI FI SI
set DeltaI "NotFound"
if {$I!=""} {
set DeltaI 0
set LeTfaI [LaSequenceDesBanques $RI]; set EI [lindex $LeTfaB 0]
}
set DeltaB [expr $M-$FB]
set DeltaA [expr $DA-$M]
set LeTfaB [LaSequenceDesBanques $RB]; set EB [lindex $LeTfaB 0]
set LeTfaA [LaSequenceDesBanques $RA]; set EA [lindex $LeTfaA 0]
set Ok ""
if {$DeltaI==0} {
if {[regexp -nocase $Name $EI]} {
set Ok "Hourrahhhh"
Espionne "\n$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA Inside $RI $Ok"
lappend LesInside "$N $Name $M $Strand $SI $DI $FI $DeltaI $RI $EI"
continue
}
}
if {$DeltaB < $DeltaA} {
if {[regexp -nocase $Name $EB]} {
set Ok "Hourrahhhh"
Espionne "\n$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA Before $RB $Ok"
lappend LesBefore "$N $Name $M $Strand $SB $DB $FB $DeltaB $RB $EB"
continue
}
}
if {$DeltaA < $DeltaB} {
if {[regexp -nocase $Name $EA]} {
set Ok "Hourrahhhh"
Espionne "\n$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA After $RA $Ok"
lappend LesAfter "$N $Name $M $Strand $SA $DA $FA $DeltaA $RA $EA"
continue
}
}
if {$DeltaA == $DeltaB} {
FaireLire "$N $Name $FB $M $DA $DeltaB $DeltaA Equality !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
}
if {$Ok==""} {
Espionne "\n$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA Before $RB Perduuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu"
Espionne "$EB\n$EA"
lappend LesPerdus "$N $Name $Strand $SB $FB $M $DA $SA $DeltaB $DeltaA \n$EB\n$EA\n"
}
}
AfficheVariable [join $LesBefore "\n"] "" "Before"
AfficheVariable [join $LesAfter "\n"] "" "After"
AfficheVariable [join $LesPerdus "\n"] "" "Perdus"
}
proc ll {} {
puts [ContenuDuFichier [RepertoireDuGenome]]
}
proc CorrigeHistolica {} {
foreach Nom [ListedesPABs] {
Espionne $Nom
set Info [ContenuDuFichier [GscopeFile $Nom "infos"]]
regsub -all "histolica" $Info "histolytica" Info
Sauve $Info dans [GscopeFile $Nom "infos"]
}
}
proc InfHomolog {{Qui ""} {Quoi ""} {Ou ""}} {
if {$Ou==""} { set Ou "Sc" }
if {$Quoi==""} { set Quoi "GscopeId" }
set R [ExtraitInfo $Qui "Reciproc1_blastp$Ou:"]
if {[regexp -nocase "^No" $R]} { return "" }
if {$Quoi=="GscopeId"} { return $R }
set FicTfa "[RepertoireDuGenome]/prottfa$Ou/$R"
if {[FileAbsent $FicTfa]} { return "" }
if {[string equal -nocase $Quoi "Filename"]} { return $FicTfa }
if {[string equal -nocase $Quoi "TFA"]} { return [ContenuDuFichier $FicTfa] }
if {[regexp -nocase "Info" $Quoi]} {
set Entete [PremiereLigneDuFichier $FicTfa]
if {[regexp -nocase "Show" $Quoi]} { return [YEAHshowYeast $Entete "Show"] }
set Info [YEAHshowYeast $Entete "Get"]
if {[regexp -nocase "Get" $Quoi]} {
if {[regexp -nocase "Locus" $Quoi]} { return [StringApres "Locus_Name...:" dans $Info] }
if {[regexp -nocase "Desc" $Quoi]} { return [StringApres "Description..:" dans $Info] }
if {[regexp -nocase "ORF" $Quoi]} { return [StringApres "ORF_Name.....:" dans $Info] }
return $Info
}
return $Info
}
return ""
}
proc PhyloDistribution {{Qui ""} {Quoi ""} {GetWhat ""}} {
global PhyloDistribution
if {$Qui ==""} { set Qui "ListOf" }
if {$Quoi=="" && $Qui!="ListOf"} { set Quoi "Name" }
if {$Quoi=="" && $Qui=="ListOf"} { set Quoi "CombiCount" }
if {$Qui=="ChooseCombi"} { set Qui [ChoixParmi [PhyloDistribution ListOf Combi]] }
if {$GetWhat==""} { set GetWhat "GetData" }
if {[info exists PhyloDistribution($Qui,$Quoi)]} {
if {$GetWhat=="Show"} { return [AfficheVariable [join $PhyloDistribution($Qui,$Quoi) "\n"] "" "PhyloDistribution_${Qui}_${Quoi}"] }
return $PhyloDistribution($Qui,$Quoi)
}
if {[info exists PhyloDistribution("EstCharge")]} { return "" }
set PhyloDistribution("EstCharge") 1
set UseFiles 1
if {$Quoi=="Reset"} {
set UseFiles 0
set Quoi "NameCount"
}
set LesCombis [list \
ScM \
ScP \
TbM \
TbP \
EhM \
EhP \
ScMTbM \
TbMEhM \
EhMScM \
ScMTbP \
TbMEhP \
EhMScP \
ScPTbM \
TbPEhM \
EhPScM \
ScPTbP \
TbPEhP \
EhPScP \
ScMTbMEhM \
ScMTbMEhP \
ScMTbPEhM \
ScMTbPEhP \
ScPTbMEhM \
ScPTbMEhP \
ScPTbPEhM \
ScPTbPEhP \
]
set PhyloDistribution(ListOf,Combi) $LesCombis
foreach Combi $LesCombis {
if {[file exists "[Fiches]/$Combi"] && ($UseFiles || [string length $Combi]==3)} {
set ListeName [LesLignesDuFichier "[Fiches]/$Combi"]
set $Combi $ListeName
} else {
set A [string range $Combi 0 2]
set B [string range $Combi 3 end]
set ListeName [ListsIntersection [set $A] [set $B]]
set $Combi $ListeName
SauveLesLignes $ListeName dans "[Fiches]/$Combi"
}
set PhyloDistribution($Combi,Name) $ListeName
set PhyloDistribution($Combi,Count) [llength $ListeName]
lappend PhyloDistribution(ListOf,CombiCount) "$Combi [llength $ListeName]"
}
return [PhyloDistribution $Qui $Quoi $GetWhat]
}
proc YesScNoTb {{Un ""}} {
if {$Un==""} { set Un "1"}
set LesSc {}
foreach Nom [ListeDesPABs] {
set Sc [ExtraitInfo $Nom "Reciproc${Un}_blastpSc:"]
if {$Sc==""} { continue }
set Tb [ExtraitInfo $Nom "Reciproc_blastpTbrucei:"]
if { [regexp "^No" $Sc]} { continue }
if { ! [regexp "^No" $Tb]} { continue }
set FichierProtSc "[RepertoireDuGenome]/prottfaSc/$Sc"
set Entete [EnteteDuFichierTFA $FichierProtSc]
set Info [YEAHshowYeast $Entete "Get"]
set InfoDe($Sc) $Info
lappend HameconDe($Sc) $Nom
lappend LesSc $Sc
}
set LesSc [lsort -unique $LesSc]
set LaSortie {}
foreach Sc $LesSc {
lappend LaSortie "$Sc\n$InfoDe($Sc)\n[join $HameconDe($Sc) "\n"]"
}
set Sortie [join $LaSortie "\n\n"]
AfficheVariable $Sortie "" "AllWithScWithoutTb"
}
proc YesScNoEh {{Un ""}} {
if {$Un==""} { set Un "1"}
set LesSc {}
foreach Nom [ListeDesPABs] {
set Sc [ExtraitInfo $Nom "Reciproc${Un}_blastpSc:"]
set Eh [ExtraitInfo $Nom "Reciproc1_blastpEhistolica:"]
if { [regexp "^No" $Sc]} { continue }
if { ! [regexp "^No" $Eh]} { continue }
set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfaSc/$Sc"]
set Info [YEAHshowYeast $Entete "Get"]
set InfoDe($Sc) $Info
lappend HameconDe($Sc) $Nom
lappend LesSc $Sc
}
set LesSc [lsort -unique $LesSc]
set LaSortie {}
foreach Sc $LesSc {
lappend LaSortie "$Sc\n$InfoDe($Sc)\n[join $HameconDe($Sc) "\n"]"
}
set Sortie [join $LaSortie "\n\n"]
AfficheVariable $Sortie "" "AllWithScWithoutEh"
}
proc YesScNoPf {{Un ""}} {
if {$Un==""} { set Un "1"}
set LesSc {}
foreach Nom [ListeDesPABs] {
set Sc [ExtraitInfo $Nom "Reciproc${Un}_blastpSc:"]
set Pf [ExtraitInfo $Nom "Reciproc_blastpPfalciparum:"]
if { [regexp "^No" $Sc]} { continue }
if { ! [regexp "^No" $Pf]} { continue }
set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfaSc/$Sc"]
set Info [YEAHshowYeast $Entete "Get"]
set InfoDe($Sc) $Info
lappend HameconDe($Sc) $Nom
lappend LesSc $Sc
}
set LesSc [lsort -unique $LesSc]
set LaSortie {}
foreach Sc $LesSc {
lappend LaSortie "$Sc\n$InfoDe($Sc)\n[join $HameconDe($Sc) "\n"]"
}
set Sortie [join $LaSortie "\n\n"]
AfficheVariable $Sortie "" "AllWithScWithoutPf"
}
proc RecupereSc {} {
foreach Ligne [LesLignesDuFichier [Fiches]/lili] {
set B [lindex [split $Ligne " "] end]
set B "/home/bedez/junkdir/$B"
regsub ".blastp$" $B "" F
scan [ContenuDuFichier $F] "%s" Sc
regsub ">" $Sc "" Sc
if {[FileAbsent "[RepertoireDuGenome]/prottfaSc/$Sc"]} { file copy $F "[RepertoireDuGenome]/prottfaSc/$Sc" }
if {[FileAbsent "[RepertoireDuGenome]/blastpScReciproc/$Sc"]} { file copy $B "[RepertoireDuGenome]/blastpScReciproc/$Sc" }
}
}
proc BestHitReciprocPourTous {{BlastDir ""} {CutPN ""} {HitOnly ""}} {
set Bla [file tail $BlastDir]
foreach Nom [ListeDesPABs] {
set Reciproc [BestHitReciproc $Nom $BlastDir $CutPN $HitOnly]
Espionne "$Nom Reciproc1_$Bla: $Reciproc"
InformeSansDemander $Nom "Reciproc1_$Bla: $Reciproc"
}
}
proc BestHitReciproc {Nom {BlastDir ""} {CutPN ""} {HitOnly ""}} {
if { ! [regexp "/" $BlastDir]} { set BlastDir [RepertoireDuGenome]/$BlastDir }
if {$CutPN==""} { set CutPN 1.0e-3 }
set FiBlast "$BlastDir/$Nom"
if {[FileAbsent $FiBlast]} { return "NoBlastFile" }
set N [DecortiqueBlast $FiBlast $CutPN 1 aQuery lBanqueId lAccess lDE]
if {$N==0} { return "NoHitFound" }
set BanqueId [lindex $lBanqueId 0]
if {$HitOnly=="HitOnly"} { return $BanqueId }
set Access [lindex $lAccess 0]
set AccessOk ""
set LeHit [LaSequenceDesBanques $BanqueId $Access AccessOk]
if {$LeHit=={}} { return "NoSequenceFor$AccessOk" }
set Hit [join $LeHit "\n"]
set Hit [SequenceFormatTFA $Hit]
set Racine [file tail [RepertoireDuGenome]]
set SortieBlast [Blast "blastp" $Hit "retourne" "[RepertoireDuGenome]/banques/$Racine"]
if {$SortieBlast==""} { return "NoBlastResultFor$AccessOk" }
Sauve $SortieBlast dans "${BlastDir}Reciproc/$AccessOk"
set MaxValable 1
set N [DecortiqueBlast $SortieBlast $CutPN $MaxValable aQuery lBanqueId lAccess lDE]
foreach BanqueId $lBanqueId {
if {$BanqueId==$Nom} {
return $AccessOk
}
}
return "NoReciprocalHitFor$AccessOk"
}
proc Pfalciparum {} {
set Dir "/genomics/link/Pfalciparum"
set Pep "$Dir/DuTigr/PFA1.pep"
set Prefixe "PF"
set LesBornes {}
set LeTFA {}
if {[FileAbsent "$Dir/prottfa"]} { file mkdir "$Dir/prottfa" }
if {[FileAbsent "$Dir/fiches"]} { file mkdir "$Dir/fiches" }
set Deb 100
set Fin [expr $Deb+300]
set Sens "F"
foreach Ligne [LesLignesDuFichier $Pep] {
if {[regexp ">" $Ligne]} {
if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" }
set LesMots [split $Ligne "|"]
ScanLaListe $LesMots A T TT D O C X Y
set O "Plasmodium falciparum"
set A [string trim $A "> "]
regsub "_" $T "" N
regsub "$Prefixe" $N "" N
set Nom "$Prefixe$N"
set Entete ">$Nom $O $D $C $X $A"
Espionne $Entete
set LeTFA [list $Entete]
lappend LesBornes ">$Nom $Deb $Fin $Sens"
incr Deb 390
set Fin [expr $Deb+300]
continue
}
lappend LeTFA $Ligne
}
if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" }
return [SauveLesLignes $LesBornes dans "$Dir/fiches/bornesdespabs"]
}
proc TbruceiChromosomes {} {
foreach Fichier [lsort [glob "[RepertoireDuGenome]/DuTigr/Tbrucei_chr*.tfa"]] {
regsub -all {\.tfa+$} $Fichier "" NewFichier
set Racine [file tail $NewFichier]
append NewFichier ".new"
set LesLignes [LesLignesDuFichier $Fichier]
set OnAttendLeDebut 1
foreach Ligne $LesLignes {
if {$OnAttendLeDebut && ! [regexp {^>} $Ligne]} { continue }
if {$OnAttendLeDebut} {
set Entete $Ligne
scan $Entete "%s" Access
regsub ">" $Access "" Access
set Entete [StringSuivant " " dans $Entete]
set Entete ">$Racine $Entete $Access"
Espionne $Entete
set OnAttendLeDebut 0
set LeNew [list $Entete]
continue
}
if {[regexp -nocase {[^ATGCNMYWRK]} $Ligne] && [OuiOuNon "Est-ce la fin en \n$Ligne"]} { break }
lappend LeNew $Ligne
}
lappend LesNews [SauveLesLignes $LeNew dans $NewFichier]
}
return $LesNews
}
proc TbruceiNuc {} {
set Dir "/genomics/link/Tbrucei"
file mkdir "$Dir/nuctfa"
set LeTFA {}
foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/DuTigr/TBA1.cds"] {
if {[regexp ">" $Ligne]} {
if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/nuctfa/$Nom" }
set Ligne [string trim $Ligne "> "]
set LesMots [split $Ligne "/ "]
ScanLaListe $LesMots A
set O "Trypanosoma brucei"
set Nom $A
regsub "Tb" $Nom "TB" Nom
regsub {[^TB0-9\.]} $Nom "" Nom
set Entete ">$Nom $O $Ligne"
Espionne $Entete
set LeTFA [list $Entete]
continue
}
lappend LeTFA $Ligne
}
if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/nuctfa/$Nom" }
return
}
proc Tbrucei {} {
set Dir "/genomics/link/Tbrucei"
file mkdir "$Dir/beton"
file mkdir "$Dir/fiches"
file mkdir "$Dir/prottfa"
set Pep "$Dir/DuTigr/TBA1.pep"
set Prefixe "TB"
set LesBornes {}
set LeTFA {}
if {[FileAbsent "$Dir/prottfa"]} { file mkdir "$Dir/prottfa" }
if {[FileAbsent "$Dir/fiches"]} { file mkdir "$Dir/fiches" }
set Deb 100
set Fin [expr $Deb+300]
set Sens "F"
foreach Ligne [LesLignesDuFichier $Pep] {
if {[regexp ">" $Ligne]} {
if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" }
set Ligne [string trim $Ligne "> "]
set LesMots [split $Ligne "/ "]
ScanLaListe $LesMots A
set O "Trypanosoma brucei"
set Nom $A
regsub "Tb" $Nom "TB" Nom
regsub {[^TB0-9\.]} $Nom "" Nom
set Entete ">$Nom $O $Ligne"
Espionne $Entete
set LeTFA [list $Entete]
lappend LesBornes ">$Nom $Deb $Fin $Sens"
incr Deb 390
set Fin [expr $Deb+300]
continue
}
lappend LeTFA $Ligne
}
if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" }
return [SauveLesLignes $LesBornes dans "$Dir/fiches/bornesdespabs"]
}
proc Tparva {} {
set Dir "/genomics/link/Tparva"
set Pep "$Dir/DuTigr/TPA1.pep"
set Prefixe "TP"
set LesBornes {}
set LeTFA {}
if {[FileAbsent "$Dir/prottfa"]} { file mkdir "$Dir/prottfa" }
if {[FileAbsent "$Dir/fiches"]} { file mkdir "$Dir/fiches" }
set Deb 100
set Fin [expr $Deb+300]
set Sens "F"
foreach Ligne [LesLignesDuFichier $Pep] {
if {[regexp ">" $Ligne]} {
if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" }
set LesMots [split $Ligne "|"]
ScanLaListe $LesMots A T TT D O C X Y
set A [string trim $A "> "]
regsub "_" $T "" N
regsub "TP0" $N "" N
set Nom "$Prefixe$N"
set LeTFA [list ">$Nom $O $D $C $X $A"]
lappend LesBornes ">$Nom $Deb $Fin $Sens"
incr Deb 390
set Fin [expr $Deb+300]
continue
}
lappend LeTFA $Ligne
}
if {$LeTFA!={}} { SauveLesLignes $LeTFA dans "$Dir/prottfa/$Nom" }
return [SauveLesLignes $LesBornes dans "$Dir/fiches/bornesdespabs"]
}
proc YEAHcreateGoodAlignment {{Fichier ""}} {
if {$Fichier==""} { set Fichier [ButineArborescence "All"] }
set FiRsfOri [GscopeFile "YEAH000001" rsforiginal]
file copy -force $Fichier $FiRsfOri
set MaquRsf [YEAHmaquilleRsf $Fichier]
set GoodRsf [YEAHcorrigeOffsetEtSpaceEtTilde $MaquRsf]
set FiRsf [GscopeFile "YEAH000001" rsf]
file copy -force $GoodRsf $FiRsf
set GoodMsf [ConvertToMsf $GoodRsf "GetFile"]
set FiMsf [GscopeFile "YEAH000001" msf]
file copy -force $GoodMsf $FiMsf
Espionne "I created $FiMsf"
set LesMauvais [YEAHbadThingsInAlignment $FiMsf]
if {$LesMauvais!={}} { AfficheVariable [join $LesMauvais "\n"] "AvecFetch" "BadThingsInAlignment" }
set FiMacsimXml [GscopeFile "YEAH000001" macsimXml]
set FiMacsimRsf [GscopeFile "YEAH000001" macsimRsf]
Macsims $FiMsf "DeleteXmlFile" $FiMacsimRsf
ReordonneRsf $FiMacsimRsf "OrderFromMsf" "SameFile"
exec clustalw $FiMacsimRsf -convert -output=macsims -outfile=$FiMacsimXml -outorder=input
return $FiMacsimXml
}
proc YEAHcorrigeOffsetEtSpaceEtTilde {{Fichier ""}} {
if {$Fichier==""} { set Fichier [ButineArborescence "" "[RepertoireDuGenome]/DeJohan"] }
set LeNew {}
set OnAttendSeq 1
set DansSeq 0
set Offset 0
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp "^offset " $Ligne]} {
set Offset [IntegerApres "offset" dans $Ligne]
continue
}
if {$OnAttendSeq} {
if {[regexp "^sequence" $Ligne]} {
set OnAttendSeq 0
set DansSeq 1
set Sequence [string repeat "." $Offset]
}
lappend LeNew $Ligne
continue
}
if {$DansSeq} {
if {[regexp {^\}} $Ligne]} {
set OnAttendSeq 1
set DansSeq 0
set Offset 0
set LaSequence {}
set SequenceRestante $Sequence
while 1 {
if {$SequenceRestante==""} { break }
set Bout [string range $SequenceRestante 0 59]
set SequenceRestante [string range $SequenceRestante 60 end]
lappend LeNew " $Bout"
}
lappend LeNew $Ligne
continue
}
set Seq [string range $Ligne 2 end]
regsub -all {[ ~]} $Seq "." Seq
append Sequence $Seq
continue
}
lappend LeNew $Ligne
}
regsub ".rsf" $Fichier "-OK.rsf" NewFichier
return [SauveLesLignes $LeNew dans $NewFichier]
}
proc YEAHbadThingsInAlignment {{FichierSource ""}} {
if {$FichierSource==""} { set FichierSource "[RepertoireDuGenome]/msf/YEAH000001" }
set LesLignes [LesLignesDuFichier $FichierSource]
DecortiqueUnMSF $FichierSource LesSources
set i 0
set OnAttend 1
set LesMauvais {}
foreach Ligne $LesLignes {
if {$OnAttend} {
if {[regexp "//" $Ligne]} { set OnAttend 0 }
continue
}
if { ! [regexp -nocase {[a-z]} $Ligne]} { set i 0 ; continue }
scan $Ligne "%s" Access
set Source [lindex $LesSources $i]
if {$Access!=$Source} { lappend LesMauvais "$Source!=$Access dans $Ligne" }
Espionne "$Source $Access"
incr i
}
return $LesMauvais
}
proc YEAHmaquilleRsf {{FichierSource ""} {FichierMaquille ""}} {
if {$FichierSource ==""} { set FichierSource [ButineArborescence "" "[RepertoireDuGenome]/DeJohan"] }
if {$FichierMaquille==""} {
set FichierMaquille $FichierSource
regsub ".rsf" $FichierMaquille "" FichierMaquille
append FichierMaquille "-maquille.rsf"
}
set LesDifferents {}
set LesNouveaux {}
set LeMaquille {}
foreach Ligne [LesLignesDuFichier $FichierSource] {
if { ! [regexp -nocase {^name +([^ ]+)} $Ligne Match Access]} { lappend LeMaquille $Ligne ; continue }
set Nouveau $Access
if {[regexp -nocase {^[0-9]+$} $Nouveau]} { set Nouveau "n:$Nouveau" }
if { ! [regexp -nocase {[a-z]} $Nouveau]} { set Nouveau $Source }
while {[info exists DejaVu($Nouveau)]} { append Nouveau "_2" }
set DejaVu($Nouveau) $Access
lappend LesNouveaux $Nouveau
if {$Access!=$Nouveau} { lappend LesDifferents "$Access $Nouveau" }
lappend LeMaquille "name $Nouveau"
}
regsub {\.rsf$} $FichierMaquille "" FichierDiff
append FichierDiff "-DIFFERENCES.txt"
set Diff [SauveLesLignes $LesDifferents dans $FichierDiff]
set FM [SauveLesLignes $LeMaquille dans $FichierMaquille]
AfficheFichier $FichierDiff
return $FM
}
proc YEAHmaquilleAlignmentOld {{FichierSource ""} {FichierMaquille ""}} {
if {$FichierSource ==""} { set FichierSource [GscopeFile YEAH000001 "msf"] }
if {$FichierMaquille==""} { set FichierMaquille [GscopeFile YEAH000001 "msfwithlinks"] ; file mkdir "[RepertoireDuGenome]/msfwithlinks" }
set LesNouveaux {}
DecortiqueUnMSF $FichierSource LesSources
set MaxAccess -1
foreach Source $LesSources {
set Nouveau $Source
if { [regexp -nocase {(NP|NM|XP)_?[0-9]+$} $Source Nouveau]} {
} elseif {[regexp -nocase {^(SW|SPT)[_\:][A-Z0-9]+} $Source Nouveau]} {
} elseif {[regexp -nocase {_([A-Z0-9]{6,})$} $Source Match Nouveau]} {
}
if {[regexp -nocase {^[0-9]+$} $Nouveau]} { set Nouveau "n:$Nouveau" }
if { ! [regexp -nocase {[a-z]} $Nouveau]} { set Nouveau $Source }
while {[info exists DejaVu($Nouveau)]} { append Nouveau "_2" }
set DejaVu($Nouveau) $Source
lappend LesNouveaux $Nouveau
set MaxAccess [Maxi $MaxAccess [string length $Nouveau]]
if {$Source!=$Nouveau} { Espionne "$Source $Nouveau" }
# EspionneL [LaSequenceDesBanques $Nouveau]
}
global MaquilleNon
set MemoMaquilleNon $MaquilleNon
set MaquilleNon 0
set LeMaquille [MaquilleLeMSF $FichierSource $LesSources $LesNouveaux $MaxAccess]
set MaquilleNon $MemoMaquilleNon
set Maquille [join $LeMaquille "\n"]
set FM [Sauve $Maquille dans $FichierMaquille]
return $FM
}
proc YEAHblast {{Banque ""}} {
set SeuilExpect "1.0e-30"
set MaxListe "30"
if {$Banque==""} { set Banque "protall" }
set Queue [file tail $Banque]
foreach S [YEAHbilan "SC" "at,eh,HS"] {
foreach X [YEAHpa $S "Hs"] {
set FiTFA "[RepertoireDuGenome]/prottfa/$X"
if {[FileAbsent $FiTFA]} { continue }
set FichierBlast "[RepertoireDuGenome]/blastp$Queue/$X"
if {[FileExists $FichierBlast]} { continue }
if {[PasTouche $X]} { continue }
BlastPPourTous $FiTFA $Banque "SansPasTouche" $SeuilExpect
FinPasTouche $X
}
}
}
proc YEAHmouvement {} {
set Les340 [LesLignesDuFichier "[Fiches]/SCHS340.txt"]
foreach Ligne $Les340 {
set SCHS340($Ligne) 1
}
set Les319 [LesLignesDuFichier "[Fiches]/SCHS319.txt"]
foreach Ligne $Les319 {
set SCHS319($Ligne) 1
}
set LeTout [lsort -unique [concat $Les340 $Les319]]
set LesPerdus [list "LesPerdus"]
set LesGagnes [list "LesGagnes"]
set LesCommuns [list "LesCommuns"]
foreach Ligne $LeTout {
if {[info exists SCHS340($Ligne)]} {
if {[info exists SCHS319($Ligne)]} { lappend LesCommuns $Ligne ; continue }
lappend LesPerdus $Ligne ; continue
}
lappend LesGagnes $Ligne
}
set Dazi [join $LesPerdus "\n"]
set F [AfficheVariable $Dazi "" "SortisDes340"]
BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]"
BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa"
BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH"
set Dazi [join $LesGagnes "\n"]
set F [AfficheVariable $Dazi "" "NouveauxDans319"]
BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]"
BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa"
BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH"
set Dazi [join $LesCommuns "\n"]
set F [AfficheVariable $Dazi "" "Communs340et319"]
BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]"
BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa"
BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH"
return $F
}
proc YEAHreduitYEAHpa {} {
YEAHpa a b
set FiYEAHpa "[Fiches]/YEAHpa.txt"
set LeReduit {}
foreach Ligne [LesLignesDuFichier $FiYEAHpa] {
if {[regexp "^Sc" $Ligne]} {
scan $Ligne "%s %s" Moi Toi
if {[YEAHpa $Toi $Moi]==""} { continue }
}
lappend LeReduit $Ligne
}
return [SauveLesLignes $LeReduit dans "[Fiches]/YEAHpaReduit.txt"]
}
proc YEAHreciprocal {} {
# foreach M [YEAHpa "Sc" "MySeqs"] { }
foreach M [YEAHbilan "SC" "AT,eh,hs"] {
foreach T [YEAHpa $M OtherBests] {
if {[YEAHpa $T $M]==""} {
Espionne "$M $T [YEAHpa $M $T] [YEAHpa $T $M]"
}
}
}
}
proc WikiTable {{TexteOuFichier ""} {What ""} {Separateur ""}} {
if {$Separateur == ""} { set Separateur "\[\t|;\]" }
if {$What == ""} { set What "Show" }
if {[regexp "\n" $TexteOuFichier]} {
set Texte $TexteOuFichier
} else {
if {[file exists $TexteOuFichier]} {
set Texte [ContenuDuFichier $TexteOuFichier]
} else {
set Texte [EntreTexte $TexteOuFichier]
}
}
set LesLignes [split $Texte "\n"]
set LeNew [list "\{|"]
set Style "!"
foreach Ligne $LesLignes {
regsub -all $Separateur $Ligne "\n$Style" New
lappend LeNew "$Style$New"
lappend LeNew "|-"
set Style "|"
}
lappend LeNew "|\}"
if {$What=="Show"} { return [AfficheVariable [join $LeNew "\n"] "AvecRetour" "WikiTable"] }
if {$What=="GetList"} { return $LeNew }
if {$What=="GetText"} { return [join $LeNew "\n"] }
}
proc YeastGlossary {{Qui ""} {Quoi ""}} {
global YeastGlossary
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Locus_Name" }
if {$Quoi==""} { set Quoi "All" }
if {[info exists YeastGlossary($Qui,$Quoi)]} { return $YeastGlossary($Qui,$Quoi) }
if {[info exists YeastGlossary("EstCharge")]} {
if {[info exists YeastGlossary($Qui,Locus_Name)]} {
set Y $YeastGlossary($Qui,Locus_Name)
if {[info exists YeastGlossary($Y,$Quoi)]} { return $YeastGlossary($Y,$Quoi) }
return
}
return ""
}
set YeastGlossary("EstCharge") 1
set YeastGlossary(Filename,) "/genomics/link/YEAH/DeJohan/YeastGenenames.txt"
if {[FileAbsent $YeastGlossary(Filename,)]} { FaireLire "$YeastGlossary(Filename,) n'existe pas" ; return "" }
foreach Ligne [LesLignesDuFichier $YeastGlossary(Filename,)] {
set YaClef [regexp {([^\:]+)\:} $Ligne Match Clef]
if {$YaClef} {
set Valeur [string trim [StringSuivant $Match dans $Ligne]]
if {$Clef=="Locus_Name"} {
set Y $Valeur
set YeastGlossary($Y,All) {}
}
if {[info exists YeastGlossary($Y,$Clef)]} {
append YeastGlossary($Y,$Clef) " $Valeur"
} else {
set YeastGlossary($Y,$Clef) $Valeur
}
if { $Clef=="Locus_Name" || $Clef=="ORF_Name" || $Clef=="SGDID" } {
set YeastGlossary($Valeur,Locus_Name) $Y
lappend YeastGlossary(ListOf,$Clef) $Valeur
}
lappend YeastGlossary($Y,All) "[string range "$Clef.............." 0 12]: $Valeur"
continue
}
set Reste [string trim $Ligne "\t "]
regsub -all {[ \t]+} $Reste " " Reste
if {$Reste!=""} {
lappend YeastGlossary($Y,All) "[string repeat " " 13] $Reste"
}
}
foreach Y $YeastGlossary(ListOf,Locus_Name) {
set YeastGlossary($Y,Txt) [join $YeastGlossary($Y,All) " "]
regsub -all { +} $YeastGlossary($Y,Txt) " " YeastGlossary($Y,Txt)
regsub -all {\.\.+} $YeastGlossary($Y,Txt) "" YeastGlossary($Y,Txt)
set YeastGlossary($Y,All) [join $YeastGlossary($Y,All) "\n"]
}
return [YeastGlossary $Qui $Quoi]
}
proc YEAHrecap {{Config ""}} {
if {$Config==""} {
set Iin "Oui"
foreach I [list "Sc"] {
foreach J [YEAHOrganisms $I] {
foreach Jin [list "Non" "Oui"] {
foreach K [YEAHOrganisms $I $J] {
foreach Kin [list "Non" "Oui"] {
foreach L [YEAHOrganisms $I $J $K] {
foreach Lin [list "Non" "Oui"] {
set Config "[$Jin $J],[$Kin $K],[$Lin $L]"
foreach S [YEAHbilan "SC" $Config] {
set LesH [YEAHpa $S Others]
foreach H $LesH {
if {$H==$S} { continue }
set FiBla "[RepertoireDuGenome]/blastpYEAH/$H"
if {[file exists $FiBla]} { continue }
lappend LesManquants "$S $H"
Espionne "$S $H"
}
}
}
}
}
}
}
}
}
}
}
proc YEAHbosse {} {
set SeuilExpect "1.0e-10"
set MaxListe "SansLimiteDeNombre"
set Banque "[RepertoireDuGenome]/banques/YEAH"
foreach S [YEAHbilan "SC" "at,EH,hs"] {
set LesH [YEAHpa $S Others]
foreach H $LesH {
set FiBla "[RepertoireDuGenome]/blastpYEAH/$H"
if {[file exists $FiBla]} { continue }
if {[PasTouche $H]} { continue }
set FiTFA "[RepertoireDuGenome]/prottfa/$H"
Espionne "$S $H"
BlastPPourTous $FiTFA $Banque "SansPasTouche" $SeuilExpect
FinPasTouche $H
}
}
}
proc YeahNon X {
return [string tolower $X]
}
proc YeahOui X {
return [string toupper $X]
}
proc YEAHfind {{Qui ""}} {
if {$Qui==""} { set Qui [Entre] }
if {$Qui==""} { return "" }
scan $Qui "%s" Qui
set Others [YEAHpa $Qui Others]
if {$Others==""} { return "" }
return [YEAHshowList $Qui $Others]
}
proc YEAHshowSc {{Sc ""} {What ""}} {
if {$What==""} { set What "All" }
if {$What=="Show"} {
set Action "Show"
set What ""
} else {
set Action "Get"
}
set Entete [EnteteDuFichierTFA "[GscopeDatabaseDir YEAH]/prottfa/$Sc"]
return [YEAHshowYeast $Entete $Action $What]
}
proc YEAHshowYeast {{Selection ""} {Action ""} {What ""}} {
if {$Action==""} { set Action "Show" }
if {$What==""} { set What "All" }
if {[regexp " " $Selection]} {
set OrfName [StringApres "gene:" dans $Selection]
} else {
scan $Selection "%s" OrfName
}
if {$OrfName==""} {
if {[PourWscope]} { return "Sorry there is no information about Yeast" }
set Selection [Entre]
if {$Selection==""} { return "" }
return [YEAHshowYeast $Selection $Action]
}
set Info [YeastGlossary $OrfName $What]
if {$Action=="Get"} { return $Info }
return [Affiche $Info "" $OrfName]
}
proc YEAHshowBlastAvecRef Qui {
set LeNew [list "<pre>"]
set FiBla "[RepertoireDuGenome]/blastpYEAH/$Qui"
if {[FileAbsent $FiBla]} { return "" }
set OnAttend 1
foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/blastpYEAH/$Qui"] {
if {$OnAttend && ! [regexp "Sequences producing significant alignments" $Ligne]} { lappend LeNew $Ligne ; continue }
set OnAttend 0
if {[regexp {^(Sc|At|Eh|Hs)[0-9]+} $Ligne Match]} {
if {[file exists "[RepertoireDuGenome]/blastpYEAH/$Match"]} {
regsub "$Match " $Ligne "" Ligne
set Ligne "<a href='[WscopeScience]&YEAHshowIt&$Match&blastpYEAH'>$Match</a> $Ligne"
}
}
lappend LeNew $Ligne
}
lappend LeNew "</pre>"
set New [join $LeNew "\n"]
return $New
}
proc YEAHshowIt {Qui Quoi} {
scan $Qui "%s" Qui
if {[PourWscope]} {
if {[regexp "blastp" $Quoi]} {
return [YEAHshowBlastAvecRef $Qui]
}
return [FileMoi $Quoi $Qui]
}
set F [AfficheFichier "[RepertoireDuGenome]/$Quoi/$Qui"]
BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]"
BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa"
BoutonneLaFenetre $F "Protall" "YEAHshowIt \[selection get\] blastpprotall"
BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH"
}
proc YEAHshowList {Selection {Liste ""}} {
regsub -all "_" $Selection " " Selection
set I ""
set J ""
set K ""
set L ""
if {$Liste==""} {
ScanLaListe [split $Selection " "] I J K L
set Liste [YEAHbilan $I "$J,$K,$L"]
}
set LeDazi {}
set LeDazi2 {}
foreach S $Liste {
set Def [EnteteDuFichierTFA "[RepertoireDuGenome]/prottfa/$S"]
regsub ">$S *" $Def "" Def
lappend LeDazi "$S $Def"
set Txt ""
if {[regexp "^Sc" $S]} {
set OrfName [StringApres "gene:" dans $Def]
set Txt [YeastGlossary $OrfName "Txt"]
}
lappend LeDazi2 "$S $Txt"
}
if {[PourWscope]} {
set LeTitre [list "<h3>This page contains two parts ... the second has Yeast information</h3>"]
set LeSaut [list "<h4>Second part with Yeast information</h4>"]
return [YEAHshowAvecRefYeastProttfaBlastp [concat $LeTitre $LeDazi $LeSaut $LeDazi2]]
}
set Dazi [join $LeDazi "\n"]
set F [AfficheVariable $Dazi "" "$I-$J-$K-$L"]
BoutonneLaFenetre $F "ShowYeast" "YEAHshowYeast \[selection get\]"
BoutonneLaFenetre $F "ShowSeq" "YEAHshowIt \[selection get\] prottfa"
BoutonneLaFenetre $F "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH"
set Dazi2 [join $LeDazi2 "\n"]
set F2 [AfficheVariable $Dazi2 "" "$I-$J-$K-$L"]
BoutonneLaFenetre $F2 "ShowYeast" "YEAHshowYeast \[selection get\]"
BoutonneLaFenetre $F2 "ShowSeq" "YEAHshowIt \[selection get\] prottfa"
BoutonneLaFenetre $F2 "ShowBlast" "YEAHshowIt \[selection get\] blastpYEAH"
return $F
}
proc YEAHshowAvecRefYeastProttfaBlastp LeDazi {
set LeNew {}
foreach Ligne $LeDazi {
if {[regexp "^<" $Ligne]} { lappend LeNew $Ligne ; continue }
scan $Ligne "%s" Sel
set Gene [StringApres "gene:" dans $Ligne]
lappend LeNew "<a href='[WscopeScience]&YEAHshowYeast&$Gene'>Yeast</a> \
<a href='gscope_html_server.tcsh?YEAH&YEAHshowIt&$Sel&prottfa'>Seq</a> \
<a href='[WscopeScience]&YEAHshowIt&$Sel&blastpYEAH'>Blast</a> $Ligne"
}
set New [join $LeNew "<br/>\n"]
return $New
}
proc YEAHshowAvecRef {LeDazi} {
set LeNew {}
foreach Ligne $LeDazi {
regsub -all " " $Ligne "_" Sel
lappend LeNew "<a href='gscope_html_server.tcsh?YEAH&YEAHshowList&$Sel'>$Ligne</a>"
}
set New [join $LeNew "<br/>\n"]
return $New
}
proc YEAHshow {} {
set LeDazi {}
set Iin "Oui"
foreach I [YEAHOrganisms] {
foreach J [YEAHOrganisms $I] {
foreach Jin [list "Non" "Oui"] {
foreach K [YEAHOrganisms $I $J] {
foreach Kin [list "Non" "Oui"] {
foreach L [YEAHOrganisms $I $J $K] {
foreach Lin [list "Non" "Oui"] {
set Liste [YEAHbilan [$Iin $I] "[$Jin $J],[$Kin $K],[$Lin $L]"]
set Ligne "[$Iin $I] [$Jin $J] [$Kin $K] [$Lin $L] [llength $Liste]"
lappend LeDazi $Ligne
}
}
}
}
}
}
}
if {[PourWscope]} {
return [YEAHshowAvecRef $LeDazi]
}
set Dazi [join $LeDazi "\n"]
set F [AfficheVariable $Dazi "" "YEAHshow"]
BoutonneLaFenetre $F "Fais-voir" "YEAHshowList \[selection get\]"
return $F
}
proc YEAHorganOf Qui {
return [string range $Qui 0 1]
}
proc YEAHbilan {Qui {Quoi ""}} {
global YEAHbilan
if {[info exists YEAHbilan($Qui,$Quoi)]} { return $YEAHbilan($Qui,$Quoi) }
if {[info exists YEAHbilan("EstCharge")]} { return "" }
set YEAHbilan("EstCharge") 1
foreach Org [YEAHOrganisms] {
foreach Autre [YEAHOrganisms] {
if {$Autre==$Org} { continue }
set YEAHbilan([YeahOui $Org],[YeahOui $Autre]) {}
set YEAHbilan([YeahOui $Org],[YeahNon $Autre]) {}
}
}
foreach Org [YEAHOrganisms] {
foreach Moi [YEAHpa $Org "MySeqs"] {
set Others [YEAHpa $Moi "OtherBests"]
# Espionne "$Moi $Others"
set nAutres 0
foreach Toi $Others {
set Autre [YEAHorganOf $Toi]
if {$Autre==$Org} { continue }
incr nAutres
lappend YEAHbilan($Moi,$Autre) "$Moi $Toi"
lappend YEAHbilan([YeahOui $Org],[YeahOui $Autre]) $Moi
}
foreach Autre [YEAHOrganisms] {
if {$Autre==$Org} { continue }
if {[info exists YEAHbilan($Moi,$Autre)]} { continue }
set YEAHbilan($Moi,[YeahNon $Autre])) $nAutres
lappend YEAHbilan([YeahOui $Org],[YeahNon $Autre]) $Moi
}
}
foreach SaS [YEAHpa $Org "MySeqs"] {
}
}
# return [YEAHbilan $Qui $Quoi]
foreach I [YEAHOrganisms] {
foreach Iin [list "Non" "Oui"] {
foreach J [YEAHOrganisms $I] {
foreach Jin [list "Non" "Oui"] {
if { ! [info exists YEAHbilan([$Iin $I],[$Jin $J])]} { set YEAHbilan([$Iin $I],[$Jin $J]) {}}
if { ! [info exists YEAHbilan([$Jin $J],[$Iin $I])]} { set YEAHbilan([$Jin $J],[$Iin $I]) {}}
foreach K [YEAHOrganisms $I $J] {
foreach Kin [list "Non" "Oui"] {
foreach L [YEAHOrganisms $I $J $K] {
foreach Lin [list "Non" "Oui"] {
if { ! [info exists YEAHbilan([$Kin $K],[$Lin $L])]} { set YEAHbilan([$Kin $K],[$Lin $L]) {}}
if { ! [info exists YEAHbilan([$Lin $L],[$Kin $K])]} { set YEAHbilan([$Lin $L],[$Kin $K]) {}}
}
}
}
}
}
}
}
}
set Iin "Oui"
foreach I [YEAHOrganisms] {
foreach J [YEAHOrganisms $I] {
foreach Jin [list "Non" "Oui"] {
foreach K [YEAHOrganisms $I $J] {
foreach Kin [list "Non" "Oui"] {
foreach L [YEAHOrganisms $I $J $K] {
foreach Lin [list "Non" "Oui"] {
set BI [$Iin $I]
set BJ [$Jin $J]
set BK [$Kin $K]
set BL [$Lin $L]
set ListeIJ $YEAHbilan([$Iin $I],[$Jin $J])
set ListeIK $YEAHbilan([$Iin $I],[$Kin $K])
set ListeIL $YEAHbilan([$Iin $I],[$Lin $L])
set ListeIJK [ListsIntersection $ListeIJ $ListeIK]
set ListeIJKL [ListsIntersection $ListeIJK $ListeIL]
set YEAHbilan([$Iin $I],[$Jin $J],[$Kin $K],[$Lin $L]) $ListeIJKL
}
}
}
}
}
}
}
return [YEAHbilan $Qui $Quoi]
set LeDazi {}
foreach Org [YEAHOrganisms] {
foreach Autre [YEAHOrganisms] {
if {$Autre==$Org} { continue }
lappend LeDazi "$Org $Autre [llength $YEAHbilan($Org,$Autre)]"
}
foreach Autre [YEAHOrganisms] {
if {$Autre==$Org} { continue }
lappend LeDazi "$Org non-$Autre [llength $YEAHbilan($Org,non-$Autre)]"
}
}
AfficheVariable [join $LeDazi "\n"]
}
proc DeDoubleYEAHpa {} {
set FiYEAHpa "[Fiches]/YEAHpa.txt"
set i -1
set LesUniques {}
foreach Ligne [LesLignesDuFichier $FiYEAHpa] {
incr i
if {[info exists DejaVu($Ligne)]} { Espionne "$i $DejaVu($Ligne) $Ligne"; continue }
set DejaVu($Ligne) $i
lappend LesUniques $Ligne
}
SauveLesLignes $LesUniques dans "[Fiches]/YEAHpaUnique.txt"
}
proc YEAHpa {Qui {Quoi ""} {Val ""}} {
global YEAHpa
if {$Val != "" && ! [info exists YEAHpa("EstCharge")]} {
YEAHpa "Load"
if {$Qui!="Load"} { return [YEAHpa $Qui $Quoi $Val] }
return ""
}
if {$Val != ""} {
if { ! [info exists YEAHpa($Qui,$Quoi)]} {
lappend YEAHpa(ListOf,Couples) "$Qui $Quoi"
lappend YEAHpa($Qui,Others) $Quoi
set YEAHpa($Qui,$Quoi) $Val
}
return $YEAHpa($Qui,$Quoi)
}
set FiYEAHpa "[Fiches]/YEAHpa.txt"
if {$Qui=="Save"} {
if { ! [info exists YEAHpa(ListOf,Couples)]} {
YEAHpa "Load"
}
if { ! [info exists YEAHpa(ListOf,Couples)]} {
return ""
}
set LesLignes {}
foreach MT $YEAHpa(ListOf,Couples) {
scan $MT "%s %s" Moi Toi
set Val $YEAHpa($Moi,$Toi)
lappend LesLignes "$Moi $Toi $Val"
}
SauveLesLignes $LesLignes dans $FiYEAHpa
return $FiYEAHpa
}
if {[info exists YEAHpa($Qui,$Quoi)]} { return $YEAHpa($Qui,$Quoi) }
if {[info exists YEAHpa("EstCharge")]} { return "" }
set YEAHpa("EstCharge") 1
if {[file exists $FiYEAHpa]} {
foreach Ligne [LesLignesDuFichier $FiYEAHpa] {
set LesMots [split $Ligne " "]
set Moi [lindex $LesMots 0]
set Org [YEAHorganOf $Moi]
lappend YEAHpa($Org,MySeqs) $Moi
set Toi [lindex $LesMots 1]
if {[info exists YEAHpa($Moi,$Toi)]} { continue }
set Aut [YEAHorganOf $Toi]
# Espionne "$Moi $Aut $Toi"
if { ! [info exists YEAHpa($Moi,$Aut)]} {
set YEAHpa($Moi,$Aut) $Toi
lappend YEAHpa($Moi,OtherBests) $Toi
}
lappend YEAHpa($Moi,$Aut-all) $Toi
set Val [lrange $LesMots 2 end]
set YEAHpa($Moi,$Toi) $Val
lappend YEAHpa($Moi,Others) $Toi
lappend YEAHpa(ListOf,Couples) "$Moi $Toi"
}
}
foreach Org [YEAHOrganisms] {
if { ! [info exists YEAHpa($Org,MySeqs)]} { set YEAHpa($Org,MySeqs) {} }
set YEAHpa($Org,MySeqs) [lsort -unique $YEAHpa($Org,MySeqs)]
}
return [YEAHpa $Qui $Quoi]
}
proc YEAHOrganisms {{A ""} {B ""} {C ""}} {
set L {}
foreach O [list "Sc" "Eh" "At" "Hs"] {
if {$A==$O} { continue }
if {$B==$O} { continue }
if {$C==$O} { continue }
lappend L $O
}
return $L
}
proc YEAHStore {{Qui ""} {Start ""} {Stop ""}} {
global YEAHStore
if {[info exists YEAHStore($Qui)]} { return $YEAHStore($Qui) }
if {$Start==""} { set Start 0 }
if {$Stop==""} { set Stop 999999 }
if {$Qui==""} { set Qui "ListOfAccess" }
if {[info exists YEAHStore($Qui)]} { return $YEAHStore($Qui) }
if {[info exists YEAHStore("EstCharge")]} { return "" }
set YEAHStore("EstCharge") 1
foreach O [YEAHOrganisms] {
set n 0
set Fi "[RepertoireDuGenome]/DeJohan/$O.tfa"
foreach Access [LaSequenceDuTFAs $Fi "LaListeDesAccess"] {
incr n
if {$n<$Start} { continue }
if {$n>$Stop} { break }
lappend YEAHStore(ListOfAccess) $Access
set TFA [LaSequenceDuTFAs $Fi $Access]
set YEAHStore($Access) $TFA
}
}
return [YEAHStore $Qui]
}
proc BlastYEAH {{Start ""} {Stop ""}} {
set SeuilExpect "1.0e-10"
set MaxListe "SansLimiteDeNombre"
set Banque "[RepertoireDuGenome]/banques/YEAH"
foreach X [YEAHStore "ListOfAccess" $Start $Stop] {
if {[YEAHpa $X]!=""} { continue }
set FiTFA "[RepertoireDuGenome]/prottfa/$X"
if {[FileAbsent $FiTFA]} {
set TFA [YEAHStore $X]
Sauve $TFA dans $FiTFA
}
continue
set FichierBlast "[RepertoireDuGenome]/blastpYEAH/$X"
if {[FileAbsent $FichierBlast]} {
if {[PasTouche $X]} { continue }
BlastPPourTous $FiTFA $Banque "SansPasTouche" $SeuilExpect
FinPasTouche $X
}
}
}
proc DecortiqueBlastYEAH {{Start ""} {Stop ""} {Attendre ""}} {
set SeuilExpect "1.0e-10"
set MaxListe "SansLimiteDeNombre"
set Banque "[RepertoireDuGenome]/banques/YEAH"
set OnAttend 0
if {$Attendre!=""} { set OnAttend 1 }
set i 0
foreach X [YEAHStore "ListOfAccess" $Start $Stop] {
if {$Attendre==""} {
if {[YEAHpa $X]!=""} { continue }
if {[YEAHpa $X "Others"]!=""} { Espionne $X ; continue }
} else {
if {$OnAttend && $X!=$Attendre} { continue }
set OnAttend 0
}
set FichierBlast "[RepertoireDuGenome]/blastpYEAH/$X"
if {[FileAbsent $FichierBlast]} { continue }
DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN
set Moi $X
Espionne $Moi
foreach Toi $lBanqueId PN $lPN DE $lDE {
YEAHpa $Moi $Toi $PN
}
if {[expr [incr i] % 100]==0} { YEAHpa "Save" }
}
YEAHpa "Save"
}
proc CreateTfasForYEAH Qui {
if {$Qui == "Sc"} {
set FiS "[RepertoireDuGenome]/DeJohan/Saccharomyces_cerevisiae.SGD1.48.pep.all.fa"
set FiSc "[RepertoireDuGenome]/DeJohan/Sc.tfa"
set i 100000
foreach Access [LaSequenceDuTFAs $FiS "LaListeDesAccess"] {
incr i
set TFA [LaSequenceDuTFAs $FiS $Access]
set Entete [EnteteDuTexteTFA $TFA]
set Def [StringSuivant " " dans $Entete]
set NewEntete "Sc$i Saccharomyces cerevisiae $Def"
Espionne $NewEntete
set Seq [QueLaSequenceDuTexteTFA $TFA]
set NewTFA [SequenceFormatTFA $Seq $NewEntete "protbrut"]
lappend LeTFA $NewTFA
}
return [SauveLesLignes $LeTFA dans $FiSc]
}
if {$Qui == "Eh"} {
set FiE "[RepertoireDuGenome]/DeJohan/entamoeba_proteome.txt"
set FiEh "[RepertoireDuGenome]/DeJohan/Eh.tfa"
set i 200000
foreach Access [LaSequenceDuTFAs $FiE "LaListeDesAccess"] {
incr i
set TFA [LaSequenceDuTFAs $FiE $Access]
set Entete [EnteteDuTexteTFA $TFA]
set Def [StringSuivant " " dans $Entete]
set NewEntete "Eh$i Entamoeba histolytica $Def ($Access)"
Espionne $NewEntete
set Seq [QueLaSequenceDuTexteTFA $TFA]
set NewTFA [SequenceFormatTFA $Seq $NewEntete "protbrut"]
lappend LeTFA $NewTFA
}
return [SauveLesLignes $LeTFA dans $FiEh]
}
if {$Qui == "At"} {
set FiA "[RepertoireDuGenome]/DeJohan/AGIrefseqAA"
set FiAt "[RepertoireDuGenome]/DeJohan/At.tfa"
set i 300000
foreach Access [LaSequenceDuTFAs $FiA "LaListeDesAccess"] {
incr i
set TFA [LaSequenceDuTFAs $FiA $Access]
set Entete [EnteteDuTexteTFA $TFA]
set Def [StringSuivant "| " dans $Entete]
regsub {\[Arabidopsis.*} $Def "" Def
set NewEntete "At$i Arabidopsis thaliana $Def ($Access)"
Espionne $NewEntete
set Seq [QueLaSequenceDuTexteTFA $TFA]
set NewTFA [SequenceFormatTFA $Seq $NewEntete "protbrut"]
lappend LeTFA $NewTFA
}
return [SauveLesLignes $LeTFA dans $FiAt]
}
if {$Qui == "Hs"} {
set FiH "[RepertoireDuGenome]/DeJohan/Homo_sapiens.NCBI36.48.pep.all.fa"
set FiHs "[RepertoireDuGenome]/DeJohan/Hs.tfa"
set i 400000
foreach Access [LaSequenceDuTFAs $FiH "LaListeDesAccess"] {
incr i
set TFA [LaSequenceDuTFAs $FiH $Access]
set Entete [EnteteDuTexteTFA $TFA]
set Def [StringSuivant " " dans $Entete]
set NewEntete "Hs$i Homo sapiens $Def"
Espionne $NewEntete
set Seq [QueLaSequenceDuTexteTFA $TFA]
set NewTFA [SequenceFormatTFA $Seq $NewEntete "protbrut"]
lappend LeTFA $NewTFA
}
return [SauveLesLignes $LeTFA dans $FiHs]
}
}
proc ReorganiseBSD {{Action ""}} {
if {$Action==""} { set Action "CreateFiles" }
set FiAll "BSDall20080306.tfa"
set i 0
set LesBons {}
set LeTFAs {}
set Bascule(gi_159480768_ref_xp_001698454.) "DOS"
set Bascule(gi_145341500_ref_xp_001415846.) "SAP"
set Bascule(gi_159474828_ref_xp_001695527.) "Other"
set Famille "P62"
set D 100
set F 1101
foreach Access [LaSequenceDuTFAs $FiAll "LaListeDesAccess"] {
set EspionneSeqPure 0
if {[regexp "gi_145341500_ref_xp_1415847" $Access]} { continue }
set Nom [NomDuOldGI $Access]
if {$Nom==""} {
FaireLire "Pas de Nom pour $Access"
set EspionneSeqPure 1
Espionne $Access
set BelAccess $Access
} else {
incr D 1200
incr F 1200
lappend LeBonOrdre "$Nom $D $F F"
if {$Action=="GetOrder"} { continue }
set OS [ExtraitInfo $Nom "OS:"]
if {[regexp "Homo sapiens" $OS]} { set OS "Homo sapiens" }
regsub {\:.*} $OS "" OS
scan $OS "%s %s" Genre Espece
set G [string index $Genre 0]
set E [string range $Espece 0 2]
if {[info exists OSduGE($G$E)] && $OSduGE($G$E)!="$Genre$Espece"} { FaireLire "$OSduGE($G$E)!= $Genre$Espece" }
set OSduGE($G$E) "$Genre$Espece"
regsub -all {[^0-9]} $Nom "" N
set BelAccess "$G$E$N"
}
if {$Action=="GetOrder"} { continue }
Espionne "$Nom $Famille $Access"
InformeSansDemander $Nom "Famille: $Famille"
set TFA [LaSequenceDuTFAs $FiAll $Access]
set Seq [QueLaSequenceDuTexteTFA $TFA]
regsub -all -nocase {[^a-z]} $Seq "" SeqPure
if {$EspionneSeqPure} { Espionne $SeqPure }
set Bon [SequenceFormatTFA $Seq $BelAccess "protbrut"]
lappend $LeTFAs $TFA
lappend LesBons $Bon
if {[info exists Bascule($Access)]} { set Famille $Bascule($Access) }
}
if {$Action=="GetOrder"} { return $LeBonOrdre }
AfficheVariable [join $LeTFAs "\n"] "" LeTFAs
AfficheVariable [join $LesBons "\n"] "" LesBons
regsub ".tfa$" $FiAll ".NEW.tfa" FiNew
if {$Action!="CerateFiles"} { return }
SauveLesLignes $LesBons dans $FiNew
regsub ".tfa$" $FiNew .msf FiNewMsf
ConvertToMsf $FiNew $FiNewMsf
}
proc NomDuOldGI GI {
global NomDuOldGI
set GI [string toupper $GI]
if {[info exists NomDuOldGI($GI)]} { return $NomDuOldGI($GI) }
if {[info exists NomDuOldGI("EstCharge")]} { return "" }
set NomDuOldGI("EstCharge") 1
foreach Nom [ListeDesPABs] {
set OldGI [ExtraitInfo $Nom "OldGI:"]
if {$OldGI==""} { continue }
set OLDGI [string toupper $OldGI]
set NomDuOldGI($OldGI) $Nom
set NomDuOldGI($OLDGI) $Nom
set Court [string range $OLDGI 0 29]
if {[info exists DejaVu($Court)]} { FaireLire "Deja vu $Court $DejaVu($Court)" }
set DejaVu($Court) $OLDGI
set NomDuOldGI($Court) $Nom
}
return [NomDuOldGI $GI]
}
proc InformeReferencePourBSD {} {
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set GI [References [string toupper $Alias]]
InformeSansDemander $Nom "OldGI: $GI"
}
}
proc InformeOrganismePourBSD {{Source ""}} {
if {$Source == ""} { set Source"organismesdespabs" }
if {[regexp -nocase "descriptif" $Source]} { set Source "descriptif" }
if {$Source == "organismesdespabs"} {
set FichierOrganisme "[RepertoireDuGenome]/fiches/organismesdespabs"
while {[FileAbsent $FichierOrganisme]} {
if {[OuiOuNon "$FichierOrganisme n'existe pas\nDois-je stopper ?"]} { exit }
set FichierOrganisme [Entre $FichierOrganisme]
}
foreach Ligne [LesLignesDuFichier $FichierOrganisme] {
Espionne $Ligne
scan $Ligne "%s" Nom
regsub "$Nom " $Ligne "" Orga
InformeSansDemander $Nom "OS: $Orga"
}
return
}
if {$Source == "descriptif"} {
foreach Nom [ListeDesPABs] {
set FichierDescriptif [GscopeFile $Nom "descriptifs"]
if {[FileAbsent $FichierDescriptif]} {
set OS "Unknown unknown"
} else {
set Meilleur [PremiereLigneDuFichier $FichierDescriptif]
set OS [ChampDuDescriptif $Meilleur "OS"]
}
InformeSansDemander $Nom "OS: $OS"
}
return
}
}
proc ReferencesBSD {} {
set FiAll "BSDall20080207.tfa"
set i 0
set LesBons {}
set LeTFAs {}
foreach Access [LaSequenceDuTFAs $FiAll "LaListeDesAccess"] {
set E [References $Access]
lappend LesBons "$E $Access"
set TFA [LaSequenceDuTFAs $FiAll $Access]
set Seq [QueLaSequenceDuTexteTFA $TFA]
set Bon [SequenceFormatTFA $Seq $E]
lappend LeTFAs $Bon
}
AfficheVariable [join $LeTFAs "\n"] "" LeTFAs
AfficheVariable [join $LesBons "\n"] "" LesBons
}
proc References Qui {
global References
set Qui [string toupper $Qui]
if {[info exists References($Qui)]} { return $References($Qui) }
if {[info exists References("EstCharge")]} { return "" }
set References("EstCharge") 1
foreach Ligne [LesLignesDuFichier "References.txt"] {
scan $Ligne "%s %s %s %s" I G E A
set Entete [string trim [StringSuivant $A dans $Ligne]]
scan $Entete "%s" Access
set A [string toupper $A]
set References($A) $Entete
set References([string toupper $Access]) $A
}
return [References $Qui]
}
proc ALaMain Quoi {
global ALaMain
if {[info exists ALaMain($Quoi)]} { return $ALaMain($Quoi) }
if {[info exists ALaMain("EstCharge")]} { return "" }
set ALaMain("EstCharge") 1
set ALaMain(gi_bsdc1_sp_q9nw68.1_) "Unknown unknown SP:q9nw68"
set ALaMain(gi_26332042_dbj_bac29751.1_) "Unknown unknown dbj:bac29751"
set ALaMain(gi_160703882_gb_eat79375.2_) "Unknown unknown gb:eat79375"
set ALaMain(gi_157336387_emb_cao71072.1_) "Unknown unknown emb:cao71072"
set ALaMain(gi_predict_edq55772.1_) "Unknown unknown edq55772"
set ALaMain(gi_125525362_gb_eay73476.1_) "Unknown unknown gb_eay73476"
set ALaMain(gi_116000504_emb_cal50184.1_) "Unknown unknown emb_cal50184"
set ALaMain(gi_sap_dm_emb_caa56416.1_b) "Unknown unknown emb_caa56416"
set ALaMain(gi_74191837_dbj_bae32869.1_) "Unknown unknown dbj_bae32869"
set ALaMain(gi_30580527_sp_q9d5v6.1_syap1_) "Unknown unknown sp_q9d5v6.1_syap1"
set ALaMain(gi_149035828_gb_edl90495.1_) "Unknown unknown gb_edl90495"
set ALaMain(gi_14042052_dbj_bab55087.1_) "Unknown unknown dbj_bab55087"
set ALaMain(gi_15779193_gb_aah14657.1_) "Unknown unknown gb_aah14657"
set ALaMain(gi_62897271_dbj_bad96576.1_) "Unknown unknown dbj_bad96576"
set ALaMain(gi_14189980_gb_aak55531.1_af30) "Unknown unknown gb_aak55531"
set ALaMain(gi_47215840_emb_cag00695.1_) "Unknown unknown emb_cag00695"
set ALaMain(gi_sap_danio_p_957236.1_) "Brachidanio rerio p_957236"
set ALaMain(gi_edp29796.1_bsd-bruggia) "Brugia malayi edp29796"
set ALaMain(gi_schistosoma_gb_aaw25233.1_) "schistosoma_ gb:aaw25233"
set ALaMain(gi_bsd_oris_aba94285.2_) "oris_ aba94285"
set ALaMain(gi_147818233_emb_can73547.1_) "Unknown unknown emb_can73547"
set ALaMain(gi_162674980_gb_edq61481.1_) "Unknown unknown gb_edq61481"
set ALaMain(gi_162683699_gb_edq70107.1_) "Unknown unknown gb_edq70107"
set ALaMain(gi_29841361_gb_aap06393.1_) "Unknown unknown gb_aap06393"
set ALaMain(gi_56753973_gb_aaw25179.1_) "Unknown unknown gb_aaw25179"
set ALaMain(gi_114636465_ref_xp_001173050.) "Unknown unknown YYY:xp_001173050"
set ALaMain(gi_predictprot_macala_xp_001085333.) "Unknown unknown YYY:xp_001085333"
set ALaMain(gi_114052006_ref_np_001039615.) "Unknown unknown YYY:np_001039615"
set ALaMain(gi_114636455_ref_xp_001173101.) "Unknown unknown YYY:xp_001173101"
set ALaMain(gi_149719503_ref_xp_001505012.) "Unknown unknown YYY:xp_001505012"
set ALaMain(gi_p62_hom_s_ref_np_005307.1) "Unknown unknown YYY:np_005307"
set ALaMain(gi_126332087_ref_xp_001366557.) "Unknown unknown YYY:xp_001366557"
set ALaMain(gi_57102734_ref_xp_534083.1) "Unknown unknown YYY:xp_534083"
set ALaMain(gi_p62_mousemgb_aah52837.1) "Unknown unknown GB:aah52837"
set ALaMain(gi_157816977_ref_np_001101955.) "Unknown unknown YYY:np_001101955"
set ALaMain(gi_31982313_ref_np_032212.2) "Unknown unknown YYY:np_032212"
set ALaMain(gi_p62_xenopustrop_np_001006921.1) "Unknown unknown YYY:np_001006921"
set ALaMain(gi_118091234_ref_xp_421013.2) "Unknown unknown YYY:xp_421013"
set ALaMain(gi_52219046_ref_np_001004596.1) "Unknown unknown YYY:np_001004596"
set ALaMain(gi_125880724_ref_xp_001342123.) "Unknown unknown YYY:xp_001342123"
set ALaMain(gi_p62putative_ref_xp_798784.1) "Unknown unknown YYY:xp_798784"
set ALaMain(gi_p62_sc__010597.1) "Saccharomyces cerevisiae YYY:010597"
set ALaMain(gi_45184782_ref_np_982500.1) "Unknown unknown YYY:np_982500"
set ALaMain(gi_156837512_ref_xp_001642780.) "Unknown unknown YYY:xp_001642780"
set ALaMain(gi_bsd_gallusgallusp_001012860) "Gallus gallus YYY:NP_001012860"
set ALaMain(gi_pdb_syap1_humana_structure) "Unknown unknown PDB:1X3A_a"
set ALaMain(gi_pdb_syap1_humanb_structure) "Unknown unknown PDB:1X3A_b"
set ALaMain(gi_cryptosporidium_ref_xp_6660) "Unknown unknown YYY:xp_6660"
set ALaMain(gi_cryptosporidium_xp_625548.1) "Unknown unknown YYY:xp_625548"
set ALaMain(gi_58261118_ref_xp_567969.1) "Unknown unknown YYY:xp_567969"
set ALaMain(gi_115692152_ref_xp_780429.2) "Unknown unknown YYY:xp_780429"
set ALaMain(gi_158287538_ref_xp_309535.4) "Unknown unknown YYY:xp_309535"
set ALaMain(gi_15233107_ref_np_191701.1) "Unknown unknown YYY:np_191701"
set ALaMain(gi_149237456_ref_xp_001524605.) "Unknown unknown YYY:xp_001524605"
set ALaMain(gi_159474828_ref_xp_001695527.) "Unknown unknown YYY:xp_001695527"
set ALaMain(gi_predict_EDQ55772.1) "Unknown unknown YYY:EDQ55772"
set ALaMain(gi_BSD_gallusgallusP_001012860.1) "Gallus gallus YYY:NP_001012860"
set ALaMain(gi_PDB_syap1_HUMANa_structure_1X3A_A_1) "Homo sapiens PDB:1X3A"
set ALaMain(gi_PDB_syap1_HUMANb_structure_1X3A_A_2) "Homo sapiens PDB:1X3A"
set ALaMain(gi_SAP_danio_P_957236.1) "Brachydanio rerio YYY:NP_957236"
set ALaMain(gi_EDP29796.1_bsd-bruggia) "Brugia malayi YYY:EDP29796"
set ALaMain(gi_BSD_ORIS_ABA94285.2) "Oryza sativa SPT:ABA94285"
set ALaMain(gi_bsdputat_Orizaesativ_BAD53348.1) "Oryza sativa SPT:BAD53348"
return [ALaMain $Quoi]
}
proc VraiNom Betise {
global VraiNom
if {[info exists VraiNom($Betise)]} { return $VraiNom($Betise) }
if {[info exists VraiNom("EstCharge")]} { return "" }
set VraiNom("EstCharge") 1
set VraiNom(dm) "Drosophila melanogaster"
set VraiNom(apis) "Apis melifera"
set VraiNom(orizaref) "Oryza sativa"
set VraiNom(kluiverxp) "Kluyveromyces lactis"
set VraiNom(pombe) "Schizosaccharomyces pombe"
set VraiNom(cryptococcus) "Cryptococcus neoformans"
set VraiNom(dictyostelium) "Dictostelium unknownus"
set VraiNom(danior) "Brachidanio rerio"
set VraiNom(panisoform) "Pan troglodytes"
set VraiNom(panisoform2) "Pan troglodytes"
set VraiNom(panisoform5) "Pan troglodytes"
set VraiNom(canis) "Canis familiaris"
set VraiNom(gallusgallusp) "Gallus gallus"
set VraiNom(xenopuslae) "Xenopus laevis"
set VraiNom(xenoplaevis) "Xenopus laevis"
set VraiNom(ncrassa) "Neurospora crassa"
set VraiNom(schyzosac) "Schizosaccharomyces pombe"
set VraiNom(athaliananref) "Arabidopsis thaliana"
set VraiNom(nasonia) "Nasonia vitripennis"
set VraiNom(bovis) "Bovis taurus"
set VraiNom(gallus) "Gallus gallus"
set VraiNom(opossum) "Opossum "
set VraiNom(nemast) "Nematostella unknownus"
set VraiNom(athalian) "Arabidopsis thaliana"
set VraiNom(orizaesativ) "Oryza sativa"
set VraiNom(tribolium) "Tribolium castaneum"
set VraiNom(mm) "Mus musculus"
set VraiNom(homosapisoform) "Homo sapiens"
set VraiNom(ATHALAINA) "Arabidopsis thaliana"
set VraiNom(athalaina) "Arabidopsis thaliana"
set VraiNom(Aspergil) "Aspergillus unknownus"
set VraiNom(aspergil) "Aspergillus unknownus"
set VraiNom(Athalian) "Arabidopsis thaliana"
set VraiNom(Athaliana) "Arabidopsis thaliana"
set VraiNom(Orizasativ) "Oryza sativa"
set VraiNom(Orizasativa) "Oryza sativa"
set VraiNom(Picea) "Picea unknownus"
set VraiNom(Saccharocerev) "Saccharomyces cerevisiae"
set VraiNom(athalian) "Arabidopsis thaliana"
set VraiNom(athaliana) "Arabidopsis thaliana"
set VraiNom(orizasativ) "Oryza sativa"
set VraiNom(orizasativa) "Oryza sativa"
set VraiNom(picea) "Picea unknownus"
set VraiNom(saccharocerev) "Saccharomyces cerevisiae"
set VraiNom(epicea) "Picea unknownus"
set VraiNom(orizasat) "Oryza sativa"
set VraiNom(orizasativ) "Oryza sativa"
set VraiNom(phycomitrella) "Phycomitrella unknownus"
set VraiNom(physcomitrel) "Phycomitrella unknownus"
set VraiNom(physcomitrella) "Phycomitrella unknownus"
set VraiNom(physcomitrellagb) "Phycomitrella unknownus"
set VraiNom(vitis) "Vitis vinifera"
set VraiNom(vitisvini) "Vitis vinifera"
set VraiNom(aedesput) "Aedes aegypti"
set VraiNom(ascomycetes) "Ascomycete sp."
set VraiNom(asper) "Aspergillus unknownus"
set VraiNom(asperg) "Aspergillus unknownus"
set VraiNom(aspergil) "Aspergillus unknownus"
set VraiNom(athalia) "Arabidopsis thaliana"
set VraiNom(athaliana) "Arabidopsis thaliana"
set VraiNom(caeno) "Caenorhabditis elegans"
set VraiNom(candida) "Candida unknownus"
set VraiNom(ce) "Caenorhabditis elegans"
set VraiNom(cryptosporidium) ""
set VraiNom(dictyostel) "Dictostelium unknownus"
set VraiNom(drozo) "Drosophila melanogaster"
set VraiNom(fungi) "Ascomycete sp."
set VraiNom(fungi-macro-gb) "Fungi unknownus"
set VraiNom(homosap) "Homo sapiens"
set VraiNom(kluiverlactis) "Kluyveromyces lactis"
set VraiNom(leishmania3) "Leishmania unknownus"
set VraiNom(monodelphis) "Monodelphis domestica"
set VraiNom(orizasativ) "Oryza sativa"
set VraiNom(orizasativa) "Oryza sativa"
set VraiNom(ornithor) "Ornithorhynchus anatinus"
set VraiNom(ostreococcus) "Ostreococcus unknownus"
set VraiNom(p62canis) "Canis familiaris"
set VraiNom(p62nematopref) "Nematode sp."
set VraiNom(pan) "Pan troglodytes"
set VraiNom(phycomitrella) "Physcomitrella patens"
set VraiNom(physcomitrellagb) "Physcomitrella patens"
set VraiNom(pichia) "Pichia pastoris"
set VraiNom(plantegb) "Plant unkownus"
set VraiNom(plasmodium) "Plasmodium sp."
set VraiNom(plasmodiumvivax) "Plasmodium vivax"
set VraiNom(sac) "Saccharomyces cerevisiae"
set VraiNom(saccharocerev) "Saccharomyces cerevisiae"
set VraiNom(sclerotina) "Sclerotinia sclerotiorum"
set VraiNom(strongylo) "Unknownus unknownus"
set VraiNom(tetraodon) "Tetraodon sp."
set VraiNom(vitis) "Vitis vinifera"
set VraiNom(xenopuslaevis) "Xenopus laevis"
set VraiNom(yeast) "Yeast unknownus"
return [VraiNom $Betise]
}
proc ValiGNHNR {} {
foreach Nom [ListeDesPABs] {
set Access [ExtraitInfo $Nom "AccessProt:"]
set GN [BirdWeb uniprot $Access GN]
Espionne $GN
set ValiGN [StringApres "Name=" dans $GN]
regsub {\;.*} $ValiGN "" ValiGN
Espionne "$Nom $Access $ValiGN"
InformeSansDemander $Nom "=ValiGN: $ValiGN"
}
exit
}
proc AccessHNR {} {
foreach Nom [ListeDesPABs] {
set Entete [EnteteDuFichierTFA [GscopeFile $Nom nuctfa]]
set Access [lindex [LesMotsDeLaLigne $Entete] 5]
InformeSansDemander $Nom "AccessProt: $Access"
}
exit
}
proc OrganismesPourGenomiqueComparative {} {
return [LesLignesDuFichier "[Fiches]/OrganismesPourGenomiqueComparative.txt"]
}
proc GenomiqueComparativeParBlast {{RepBlast ""}} {
set LaRecap {}
set Libre [string repeat " " 35]
if { ! [PourWscope]} {
set Vide ""
foreach Nom [ListeDesPABs] {
lappend LaRecap "$Libre$Vide $Nom [Alias $Nom]"
append Vide " "
}
}
lappend LaRecap "$Libre 1 2 3 4 5"
lappend LaRecap "$Libre 12345678901234567890123456789012345678901234567890"
# set LO [OrganismesPourGenomiqueComparative]
set LO [OrganismePresent RankedListOf AllOrganisms $RepBlast]
set I 0
foreach RO $LO {
incr I
scan $RO "%s %s %s" R G E
if {$E==""} { set E $G ; set G $R; set R $I }
set O "$G $E"
Espionne $O
set C [OCduOS $O]
set Recap "[format "%4d %-30s" $R $O] "
foreach Nom [ListeDesPABs] {
if {[OrganismePresent $Nom $O]==""} {
append Recap " "
} else {
append Recap "X"
}
}
append Recap " $C"
lappend LaRecap $Recap
}
set Recap [join $LaRecap "\n"]
set Bank [file tail $RepBlast]
if {[PourWscope]} {
set Header "<h2>Genomique Comparative pour [PreFixe] par $Bank</h2>"
append Header "\n<center>See all <a target='blank' href='[WscopeScience]&FileMoi'>[PreFixe]</a> in an other window.</center>"
return [Html_DuTexteTelQuel $Recap "GenomiqueComparative_$Bank" $Header]
}
set F [AfficheVariable $Recap "AvecRecap" "GenomiqueComparative_$Bank"]
return $F
}
proc OrganismePresent {{Qui ""} {Quoi ""} {RepBlast ""}} {
global OrganismePresent
regsub {[_]} $Quoi " " Quoi
if {$RepBlast==""} {
if { ! [info exists OrganismePresent(CurrentRepBlast,,)]} { set OrganismePresent(CurrentRepBlast,,) "blastnwgs"}
set RepBlast $OrganismePresent(CurrentRepBlast,,)
}
set OrganismePresent(CurrentRepBlast,,) $RepBlast
if {[regexp -nocase "wgs" $RepBlast]} {
set SourceOrganisme "FromDE"
} elseif {[regexp -nocase "completegenomes" $RepBlast]} {
set SourceOrganisme "FromOBBN"
} else {
set SourceOrganisme "FromBird"
set BankBird "uniprot"
if {[regexp -nocase "refseq\-prot" $RepBlast]} { set BankBird "REFSEQP" }
if {[regexp -nocase "refseq\-nuc" $RepBlast]} { set BankBird "REFSEQN" }
}
set OrganismePresent(CurrentRepBlast,,) $RepBlast
if {[info exists OrganismePresent($Qui,$Quoi,$RepBlast)]} { return $OrganismePresent($Qui,$Quoi,$RepBlast) }
if {[info exists OrganismePresent($RepBlast,"EstCharge",)]} { return "" }
set OrganismePresent($RepBlast,"EstCharge",) 1
set FichierOrganismePresent "[Fiches]/OrganismesPresents-[file tail $RepBlast].txt"
if {[FileExists $FichierOrganismePresent]} {
array set OrganismePresent [LesLignesDuFichier $FichierOrganismePresent]
return [OrganismePresent $Qui $Quoi $RepBlast]
}
set SeuilExpect 0.001
set MaxListe 9999
if {$RepBlast==""} { set RepBlast "blastnwgs"}
foreach Nom [ListeDesPABs] {
set FichierBlast [GscopeFile $Nom $RepBlast]
Espionne $FichierBlast
if {[FileAbsent $FichierBlast]} { continue }
DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN
set Rank 0
foreach PN $lPN BanqueId $lBanqueId Access $lAccess DE $lDE {
Espionne "$BanqueId $Access $BankBird"
if {$SourceOrganisme=="FromDE"} {
set Organisme $DE
} elseif {$SourceOrganisme=="FromBird"} {
set Organisme [BirdWeb $BankBird $Access "OS"]
} elseif {$SourceOrganisme=="FromOBBN"} {
set Access ""
if { ! [regexp {([^\:]+)\:(.+)} $BanqueId Match Bank Access]} { Espionne "$Match $Bank $Access" ; continue }
Espionne "$Match $Bank $Access"
set Organisme [OrganismeDeLaBanqueBlastN $Bank]
}
Espionne "$BanqueId $Organisme"
if {$Organisme==""} { continue }
set Genre "" ; set Espece ""
scan $Organisme "%s %s" Genre Espece
set Organisme "$Genre $Espece"
regsub -all {\,} $Organisme "" Organisme
if { ! [info exists OrganismePresent($Nom,$Organisme,$RepBlast)]} {
incr Rank
set OrganismePresent($Nom,$Organisme,$RepBlast) "$Rank $Access $PN"
lappend OrganismePresent($Nom,ListOfOrganisms,$RepBlast) $Organisme
if { ! [info exists DejaVu($Organisme)]} {
set DejaVu($Organisme) 1
lappend OrganismePresent(ListOf,AllOrganisms,$RepBlast) $Organisme
}
}
}
}
set MaxOrganismes [llength $OrganismePresent(ListOf,AllOrganisms,$RepBlast)]
foreach Organisme $OrganismePresent(ListOf,AllOrganisms,$RepBlast) {
set AverageRank 0
set I 0
foreach Nom [ListeDesPABs] {
incr I
incr AverageRank $Rank
if { ! [info exists OrganismePresent($Nom,$Organisme,$RepBlast)]} { incr AverageRank $MaxOrganismes ; continue }
set Rank $OrganismePresent($Nom,$Organisme,$RepBlast)
scan $Rank "%d" Rank
}
set AverageRank [expr $AverageRank/$I]
lappend LesRO [list $AverageRank $Organisme]
}
set LesRO [lsort -integer -index 0 $LesRO]
set LesO {}
foreach RO $LesRO {
set R [lindex $RO 0]
set O [lindex $RO 1]
lappend OrganismePresent(RankedListOf,AllOrganisms,$RepBlast) "$R $O"
lappend LesO $O
}
set OrganismePresent(ListOf,AllOrganisms,$RepBlast) $LesO
SauveLesLignes [array get OrganismePresent] dans $FichierOrganismePresent
return [OrganismePresent $Qui $Quoi $RepBlast]
}
proc PositionSurMrnaHNR {} {
set LesPositions {}
foreach Nom [ListeDesPABs] {
set FB [GscopeFile $Nom tblastnHNRallNuc]
if {[FileAbsent $FB]} { continue }
Espionne [ChaqueSegmentDuBlastN $FB 1.e-20 HNRallNuc:$Nom]
}
return $LesPositions
}
proc AlviCreePpcrProt {} {
set RepPpcrProt "[RepertoireDuGenome]/ppcrprot"
foreach Nom [ListeDesPABs] {
set TfaPpcr [ContenuDuFichier [GscopeFile $Nom "ppcr"]]
set Entete [EnteteDuTexteTFA $TfaPpcr]
set PcrNuc [QueLaSequenceDuTexteTFA $TfaPpcr]
set PosATG [string first "ATG" $PcrNuc]
set PosStop [StopProchain $PcrNuc $PosATG]
incr PosStop -1
if {$PosStop <0} { set PosStop "end" }
set PcrPro [SeqNucToSeqPro [string range $PcrNuc $PosATG $PosStop]]
set TfaPpcrProt [SequenceFormatTFA $PcrPro $Entete "protbrut"]
Espionne $TfaPpcrProt
Sauve $TfaPpcrProt dans "$RepPpcrProt/$Nom"
}
}
proc TestPCRAlvi {} {
foreach Ligne [LesLignesDuFichier "[Fiches]/OligosF.csv"] LigneR [LesLignesDuFichier "[Fiches]/OligosR.csv"] {
ScanLaListe [split $Ligne ";"] OligoNameF OligoF Bidon1 Bidon2 Bidon3 NotesF
regexp {BOX[0-9]+} $NotesF Nom
ScanLaListe [split $LigneR ";"] OligoNameR OligoR Bidon1 Bidon2 Bidon3 NotesR
set OligoRSens [NucToReverseAndComplementNuc $OligoR]
Espionne $Ligne
Espionne $LigneR
if {[regexp "RunOff" $OligoNameR]} { set OligoR "" }
set MF [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
PCR $MF $OligoF $OligoR $Nom
}
exit
}
proc PCR {MatriceForward AmorceForward AmorceReverse {Nom ""}} {
if {$Nom==""} { set Nom "[PreFixe]999999" }
set MatriceForward [string toupper $MatriceForward]
set MatriceReverse [NucToReverseAndComplementNuc $MatriceForward]
set AmorceForward [string toupper $AmorceForward]
set AmorceReverse [string toupper $AmorceReverse]
set AmorceRevSens [NucToReverseAndComplementNuc $AmorceReverse]
set TfaDom [ContenuDuFichier [GscopeFile $Nom "nucoligo"]]
set AccDom [EnteteDuTexteTFA $TfaDom "access"]
set SeqDom [QueLaSequenceDuTexteTFA $TfaDom]
set FichierPpcr [GscopeFile $Nom "ppcr"]
set PPCR ""
set TfaPpcr ""
if {[file exists $FichierPpcr]} {
set PPCR [QueLaSequenceDuFichierTFA $FichierPpcr]
set TfaPpcr [SequenceFormatTFA $PPCR "ppcr" "nucbrut"]
}
set L [string length $AmorceForward]
set MinTm 45
set Start -1
set FinHybridSurMatrice -1
set BestHybridForward ""
while 1 {
incr Start
set HybridForward [string range $AmorceForward $Start end]
if {[TMDeLaSequence $HybridForward] < $MinTm} { break }
if {[set I [string first $HybridForward $MatriceForward]]<0} { continue }
set FHSM [expr $I + $L - $Start -1]
Espionne "$FHSM $ $I + $L - $Start -1"
if {$FinHybridSurMatrice > -1 && $FHSM != $FinHybridSurMatrice} {
FaireLire "Pour $AmorceForward $FHSM != $FinHybridSurMatrice"
continue
}
if {$BestHybridForward==""} { set BestHybridForward $HybridForward }
set FinHybridSurMatrice $FHSM
}
set HybridForward $BestHybridForward
set R [string length $AmorceRevSens]
set MinTm 45
set End [string length $AmorceReverse]
set DebHybridSurMatrice -1
set BestHybridRevSens ""
while 1 {
incr End -1
set HybridRevSens [string range $AmorceRevSens 0 $End]
if {[TMDeLaSequence $HybridRevSens] < $MinTm} { break }
if {[set I [string last $HybridRevSens $MatriceForward]]<0} { continue }
set DHSM $I
Espionne "$I $HybridRevSens"
if {$DebHybridSurMatrice>-1 && $DHSM != $DebHybridSurMatrice} {
FaireLire "Pour $AmorceReverse $DHSM != $DebHybridSurMatrice"
continue
}
if {$BestHybridRevSens==""} { set BestHybridRevSens $HybridRevSens }
set DebHybridSurMatrice $DHSM
}
set HybridRevSens $BestHybridRevSens
set DebMatriceNonHybrid [expr $FinHybridSurMatrice + 1]
set FinMatriceNonHybrid [expr $DebHybridSurMatrice - 1]
if {$DebHybridSurMatrice<0} { set FinMatriceNonHybrid end }
set PcrNuc ""
append PcrNuc $AmorceForward
append PcrNuc [string range $MatriceForward $DebMatriceNonHybrid $FinMatriceNonHybrid]
append PcrNuc $AmorceRevSens
set PosATG [string first "ATG" $PcrNuc]
set PcrPro [SeqNucToSeqPro [string range $PcrNuc $PosATG end]]
regsub -all {.} $PcrPro "& " PcrPro
set OffsetProt [string repeat "+" $PosATG]
set TfaPcr [SequenceFormatTFA $PcrNuc "PcrNuc" "nucbrut"]
set TfaAF [SequenceFormatTFA $AmorceForward "AmoFor" "nucbrut"]
set TfaHF [SequenceFormatTFA $HybridForward "HybFor" "nucbrut"]
set MatriceForwardAbc ""
foreach {A B C} [split $MatriceForward ""] {
set Abc [string totitle "$A$B$C"]
append MatriceForwardAbc $Abc
}
set TfaM [SequenceFormatTFA $MatriceForward "$Nom" "nucbrut"]
set TfaX [SequenceFormatTFA $MatriceForwardAbc "Frames" "nucbrut"]
set NomAmo "AmoRev"
if {$AmorceReverse==""} { set NomAmo "RunOff" }
set TfaHR [SequenceFormatTFA $HybridRevSens "HybRev" "nucbrut"]
set TfaAR [SequenceFormatTFA $AmorceRevSens $NomAmo "nucbrut"]
set TFAsF "$TfaAF\n$TfaHF\n$TfaDom\n$TfaM\n$TfaPcr\n$TfaPpcr"
set FichierTFAsF [Sauve $TFAsF dans [TmpFile].tfa]
set FichierMsfF [GscopeFile $Nom "msfpcrF"]
set FichierTFAs5 [GscopeFile $Nom "tfas5"]
exec clustalw $FichierTFAsF -outorder=input -negative -output=gscope -outfile=$FichierMsfF
set TFAs5 [CreeLeTFAsDuMSF $FichierMsfF]
Sauve $TFAs5 dans $FichierTFAs5
set TFAsR "$TfaM\n$TfaHR\n$TfaAR"
set FichierTFAsR [Sauve $TFAsR dans [TmpFile].tfa]
set FichierMsfR [GscopeFile $Nom "msfpcrR"]
set FichierTFAs3 [GscopeFile $Nom "tfas3"]
exec clustalw $FichierTFAsR -outorder=input -negative -output=gscope -outfile=$FichierMsfR
set TFAs3 [CreeLeTFAsDuMSF $FichierMsfR]
Sauve $TFAs3 dans $FichierTFAs3
set NP 0
set NPD 0
foreach Access [LaSequenceDuTFAs $FichierTFAs5 "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $FichierTFAs5 $Access]
set Seq [QueLaSequenceDuTexteTFA $TFA]
lappend LeTexte "[format %-15s $Access] $Seq"
if {$Access=="PcrNuc"} {
set OffsetPcrNuc ""
regexp -- {^\-+} $Seq OffsetPcrNuc
}
if {$Access==$AccDom} {
set SeqProD ""
set ABC ""
set AttendDebutD 1
foreach C [split $Seq ""] {
if {$C=="-"} {
if {$AttendDebutD} { incr NPD }
append SeqProD "."
if {$ABC!=""} { FaireLire "SeqProD $SeqPro" }
continue
}
set AttendDebutD 0
append ABC $C
if {[string length $ABC]==3} {
set P [AAduCodon $ABC]
set ABC ""
append SeqProD "$P "
}
}
lappend LeTexte "[format %-15s ProtDom] $SeqProD"
}
if {$Access==$Nom} {
set SeqPro ""
set ABC ""
set AttendDebut 1
foreach C [split $Seq ""] {
if {$C=="-"} {
if {$AttendDebut} { incr NP }
append SeqPro "."
if {$ABC!=""} { FaireLire "SeqPro $SeqPro" }
continue
}
set AttendDebut 0
append ABC $C
if {[string length $ABC]==3} {
set P [AAduCodon $ABC]
set ABC ""
append SeqPro "$P "
}
}
lappend LeTexte "[format %-15s Protein] $SeqPro"
}
}
lappend LeTexte "[format %-15s PcrProt] $OffsetPcrNuc$OffsetProt$PcrPro"
set Offset [string repeat "." $NP]
foreach Access [LaSequenceDuTFAs $FichierTFAs3 "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $FichierTFAs3 $Access]
set Seq [QueLaSequenceDuTexteTFA $TFA]
lappend LeTexte "[format %-15s $Access] $Offset$Seq"
}
set Texte [join $LeTexte "\n"]
set T [AfficheVariable $Texte "AvecRetourGrandeLargeur" "AlignementPcr/$Nom"]
}
proc AlviVerif {} {
foreach Ligne [LesLignesDuFichier "[Fiches]/OligosF.csv"] LigneR [LesLignesDuFichier "[Fiches]/OligosR.csv"] {
ScanLaListe [split $Ligne ";"] OligoNameF OligoF Bidon1 Bidon2 Bidon3 NotesF
regexp {BOX[0-9]+} $NotesF Nom
ScanLaListe [split $LigneR ";"] OligoNameR OligoR Bidon1 Bidon2 Bidon3 NotesR
set OligoRSens [NucToReverseAndComplementNuc $OligoR]
regexp {BOX[0-9]+} $NotesR NomR
if {$Nom!=$NomR} { FaireLire COUCOU }
set SeqOliNucF [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nucoligo"]]
regsub {^ATG} $SeqOliNucF "" SeqF
regsub {.+CATATG} $OligoF "" SeF
set SeqOliNucR [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nucoligo"]]
set SeR [string range $SeqOliNucR end-25 end]
Espionne
Espionne "$OligoNameF $OligoF [string range $NotesF 0 60]"
Espionne " $SeF"
Espionne " [string range $SeqF 0 20]"
Espionne "$OligoNameR $OligoRSens [string range $NotesR 0 60]"
if {[regexp "RunOff" $NotesR]} { set SeR "RunOff" }
Espionne " $SeR"
}
}
proc SequencageAlvi {} {
set Projet [file tail [RepertoireDuGenome]]
foreach FiSeq [lsort [glob -nocomplain "[RepertoireDuGenome]/sequencage/*.seq"]] {
regsub {\.seq$} $FiSeq ".tfa" FiTfa
set Queue [file tail $FiSeq]
regsub ".seq" $Queue "" NS
regsub "AP-" $NS "" NS
if {[FileAbsent $FiTfa]} {
set Seq [ContenuDuFichier $FiSeq]
set TFA [SequenceFormatTFA $Seq $NS nucbrut]
Sauve $TFA dans $FiTfa
Espionne $FiTfa
}
set FiBla "[RepertoireDuGenome]/blastseq/$NS"
if {[FileAbsent $FiBla]} {
set TFA [ContenuDuFichier $FiTfa]
set Nuc [QueLaSequenceDuTexteTFA $TFA]
regsub -nocase -all {[ATGC]} $Nuc "" Nuc
if {[string length $Nuc] < 10} { Espionne "$NS mauvaise sequence=$Nuc=" ; continue }
set Sortie [Blast blastn $TFA $FiBla "[RepertoireDuGenome]/banques/${Projet}NucOli"]
Espionne $Sortie
}
Espionne
set Best 0
set LesHits [DecortiqueBlat $FiBla]
foreach LeHit $LesHits {
ScanLaListe $LeHit Query LongQuery BId Access Length Score Expect Identities Strand \
DebQuery FinQuery DebSbjct FinSbjct SeqQuery Barres SeqSbjct]
set Access "x"
if {[IntegerApres "/" dans $Identities]<200} { continue }
if {$Score < 0.8*$Best} { continue }
if {$Best==0} { set Best $Score }
Espionne "[format %-25s $Query] $LongQuery $BId $Access $Length $Score $Expect $Identities $Strand"
regsub -- {\-.*} $BId "" Nom
set Affecte 1
if {[info exists IdDe($Nom)]} {
set Old [IntegerApres "/" dans $IdDe($Nom)]
set New [IntegerApres "/" dans $Identities]
set Affecte [expr $New > $Old]
}
if {$Affecte} {
set IdDe($Nom) "$Identities"
set LeHitDe($Nom) [join $LeHit " "]
}
}
}
NousAllonsAuBoulot "[RepertoireDuGenome]/blastseq"
foreach Nom [ListeDesPABs] {
if { ! [info exists LeHitDe($Nom)]} { continue }
InformeSansDemander $Nom "BlastSeq: $LeHitDe($Nom)"
scan $LeHitDe($Nom) "%s" Queue
exec ln -sf $Queue $Nom
}
}
proc CreateOligosAndPpcrForAlvi {} {
set TMvoulu 60
set RepPpcr "[RepertoireDuGenome]/ppcr"
if {[FileAbsent $$RepPpcr]} { file mkdir $RepPpcr }
set FichierOrdre "[Fiches]/pour_oligosAlvi.csv"
set Queue [file tail $FichierOrdre]
regsub -nocase {\.[^\.]+$} $Queue "" Queue
LoadTxl $FichierOrdre T -1 ","
set LesHeaders $T(ListHeaderPlease,$Queue)
Espionne $LesHeaders
foreach I $T(ListAllPlease,$Queue) {
Espionne $I
foreach Header $LesHeaders {
set $Header $T($I,$Header)
}
if {$Nom_Demandeur==""} { set Nom_Demandeur $OldNom_Demandeur }
set OldNom_Demandeur $Nom_Demandeur
if {$Query==""} { set Query $OldQuery }
set OldQuery $Query
set LaLigne [list $Ordre_commande $GscopeId $Plaque_Oligos $Clone $GscopeProjects $Nom_Demandeur $Query]
set Infos($GscopeId) $LaLigne
lappend LesLignes $LaLigne
Espionne $LaLigne
}
set LesLignes [lsort -index 0 -integer $LesLignes]
set NoSitePlease "NoSitePlease"
set LesSites5ATester [list "NdeI" "force_NdeI"]
set LesSites3ATester [list "BamHI" "BglII" "force_$NoSitePlease"]
foreach Site [concat $LesSites5ATester $LesSites3ATester] {
regsub "force_" $Site "" SiteVrai
if {$SiteVrai==$NoSitePlease} {
set SeqSite($Site) "I'm not a -DNA- sequence"
} else {
set SeqSite($Site) [QuestionDeScience ProGS "ret Signal $SiteVrai SEQ"]
}
}
foreach LaLigne $LesLignes {
ScanLaListe $LaLigne Ordre_commande GscopeId Plaque_Oligos Clone GscopeProjects Nom_Demandeur Query
set Nom $GscopeId
if {[ExtraitInfo $Nom "Junk:"]!=""} { continue }
set Alias [Alias $Nom]
set DE [ExtraitInfo $Nom "DE:"]
set OliC [ExtraitInfo $Nom "OliC:"]
set CterUnknown [regexp -nocase "^no" $OliC]
set AccessStartEnd [EnteteDuFichierTFA [GscopeFile $Nom "nucoligo"] "access"]
ScanLaListe [split $AccessStartEnd "-"] Bidon Start End
set TFA [ContenuDuFichier [GscopeFile $Nom "nuctfa"]]
set Seq "n[QueLaSequenceDuTexteTFA $TFA]"
set Ent [EnteteDuTexteTFA $TFA]
set CodonStart [string range $Seq $Start [expr $Start +2]]
set CodonEnd [string range $Seq [expr $End -2] $End]
set Debut 1
if {[string equal -nocase $CodonStart "ATG"]} { set Debut 2 }
set Fin [expr ($End - $Start +1)/3]
if {[CodonStopPossible $CodonEnd]} { incr Fin -1 }
set SeqPGS [string range $Seq $Start $End]
set EntPGS "$Alias Alvinella pompejana"
if {$DE!=""} { append EntPGS " $DE" }
append EntPGS " from $Nom"
set RunOff ""
if {$CterUnknown} {
set RunOff "RunOffpME18S"
if {[regexp "^ALEN" [Alias $Nom]]} { set RunOff "RunOffpDONR222" }
append EntPGS " Cter sequence unknown, use RunOff oligo $RunOff"
}
set TFAPGS [SequenceFormatTFA $SeqPGS $EntPGS "nucbrut"]
set SEQPGS [string toupper "$SeqPGS"]
set BonSite5 ""
foreach Site $LesSites5ATester {
if {[regexp "^force_" $Site]} {
regsub "force_" $Site "" SiteVrai
set BonSite5 $SiteVrai
break
}
set SeqSi $SeqSite($Site)
set Indice [string first $SeqSi "n$SEQPGS"]
if {$Indice==-1} { set BonSite5 $Site ; break }
}
set BonSite3 ""
foreach Site $LesSites3ATester {
if {[regexp "^force_" $Site]} {
regsub "force_" $Site "" SiteVrai
set BonSite3 $SiteVrai
break
}
set SeqSi $SeqSite($Site)
set Indice [string first $SeqSi "n$SEQPGS"]
if {$Indice==-1} { set BonSite3 $Site ; break }
}
Espionne "$Nom $BonSite5 $BonSite3"
if {$BonSite5==$NoSitePlease} { set Ajout5 "" } else { set Ajout5 "_$BonSite5" }
if {$BonSite3==$NoSitePlease} { set Ajout3 "" } else { set Ajout3 "_$BonSite3" }
#rR sans AttB1 car BrocOli
set S5 "Thrombin${Ajout5}"
set S3 "STOP${Ajout3}_AttB2"
set Sujet "${Alias}-${Debut}-${Fin}"
if {$RunOff!=""} { set S3 ${RunOff}_AttB2 }
set Commande "${S5}_${Sujet}_$S3 $Clone"
Espionne "$Nom $Commande\n$TFAPGS\n"
#rR Gros bug tous les oligos 5 sont faux detecte le 1/6/2007
#rR set SeqSens [string range $SeqPGS [expr ($Debut-1)*3 + 2] [expr ($Fin-1)*3 + 2]]
set SeqSens [string range $SeqPGS [expr ($Debut-1)*3] [expr ($Fin-1)*3 + 2]]
set Entamme5 [EntammePourMeltingTemp $SeqSens $TMvoulu]
set Oligo5 ""
set SeqSignaux5 ""
foreach Signal [split $S5 "_"] {
set SS [Signal $Signal "SEQ"]
append SeqSignaux5 $SS
append Oligo5 $SS
}
append Oligo5 $Entamme5
set SeqRAC [NucToReverseAndComplementNuc $SeqSens]
if {$RunOff!=""} {
set Entamme3 ""
} else {
set Entamme3 [NucToReverseAndComplementNuc [EntammePourMeltingTemp $SeqRAC $TMvoulu]]
}
set Oligo3 $Entamme3
set SeqSignaux3 ""
foreach Signal [split $S3 "_"] {
set SS [Signal $Signal "SEQ"]
append SeqSignaux3 $SS
append Oligo3 $SS
}
set Oligo3RAC [NucToReverseAndComplementNuc $Oligo3]
Espionne $Oligo5
Espionne $Oligo3
regsub "[PreFixe]" $Nom "" Numero
set Numero [Base10 $Numero]
set OligoNameF [format "%s%5.5d%s" Ap $Numero F]
set OligoNameR [format "%s%5.5d%s" Ap $Numero R]
if {$RunOff!=""} { set OligoNameR $RunOff }
set NotesF "$OligoNameF ${S5}_${Sujet} for $GscopeId at $Plaque_Oligos $Clone $GscopeProjects $Nom_Demandeur $Query"
set NotesR "$OligoNameR ${Sujet}_${S3} for $GscopeId at $Plaque_Oligos $Clone $GscopeProjects $Nom_Demandeur $Query"
Espionne $NotesF
Espionne $NotesR
regsub -all {\s} $Oligo5 "" OligoF
regsub -all {\s} $Oligo3RAC "" OligoR
lappend LaSortieF "$OligoNameF;$OligoF;3 OD;DST;;$NotesF"
lappend LaSortieR "$OligoNameR;$OligoR;3 OD;DST;;$NotesR"
set FichierPpcr "$RepPpcr/$Nom"
if {$RunOff==""} {
set EntetePpcr "ProduitPCR_AttB1_${S5}_${Sujet}_$S3 for $Nom at $Plaque_Oligos"
set SeqPpcr "[Signal AttB1 SEQ]$SeqSignaux5$SeqSens$SeqSignaux3"
set TfaPpcr [SequenceFormatTFA $SeqPpcr $EntetePpcr "nucbrut"]
if {[FileAbsent $FichierPpcr] || [OuiOuNonMemo "Do I overwrite the NonRunOff Ppcr files?"]} {
Sauve $TfaPpcr dans $FichierPpcr
}
} else {
set N27 [string repeat "N" 27]
set EntetePpcr "ProduitPCR_AttB1_${S5}_${Sujet}_N27_$S3 for $Nom at $Plaque_Oligos !Caution! N27=3' missing sequence"
set SeqPpcr "[Signal AttB1 SEQ]$SeqSignaux5$SeqSens$N27$SeqSignaux3"
set TfaPpcr [SequenceFormatTFA $SeqPpcr $EntetePpcr "nucbrut"]
if {[FileAbsent $FichierPpcr] || [OuiOuNonMemo "Do I overwrite the RunOff Ppcr files?"]} {
Sauve $TfaPpcr dans $FichierPpcr
}
}
}
set FichierOligosF "[Fiches]/OligosF.csv"
set FichierOligosR "[Fiches]/OligosR.csv"
if {[OuiOuNon "Do I save to \n$FichierOligosF\n and \n$FichierOligosR"]} {
SauveLesLignes $LaSortieF dans $FichierOligosF
SauveLesLignes $LaSortieR dans $FichierOligosR
}
exit
}
proc CorrigeSynMito {} {
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set FichierTFA [GscopeFile $Nom prottfa]
set Seq [QueLaSequenceDuFichierTFA $FichierTFA]
set TFA [SequenceFormatTFA $Seq ">$Nom Homo sapiens mitochondrial aaRS $Alias" "protbrut"]
InformeSansDemander $Nom "ValiDE: mitochondrial aaRS $Alias"
InformeSansDemander $Nom "ValiGN: $Alias"
Sauve $TFA dans $FichierTFA
}
}
proc LanaShowTarget Selection {
global BestHit
scan $Selection "%s %s %s" Access Igbmc Merck
lappend LaPage $Selection
lappend LaPage [LocUcsc $Access "line"]
lappend LaPage ""
foreach AI [split $Igbmc "/"] {
lappend LaPage " [join $BestHit($AI) " \n"]"
}
foreach AM [split $Merck "/"] {
lappend LaPage [join $BestHit($AM) "\n"]
}
AfficheVariable [join $LaPage "\n"] "GrandeLargeur"
}
proc LanaShow {} {
global BestHit
foreach IouM [list "Igbmc" "Merck"] {
foreach Ligne [LesLignesDuFichier "[LanaRep]/BestHits$IouM"] {
ScanLaListe [split $Ligne " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct
lappend BestHit($Query) $Ligne
}
}
set F [AfficheFichier "[LanaRep]/CommonTargets" "AvecLana"]
set B [BoutonneLaFenetre $F "ShowTarget" "LanaShowTarget \[selection get\]"]
$B configure -background "black" -foreground "white"
}
proc LanaCommonTargets {{Ext ""}} {
foreach Ligne [LesLignesDuFichier "[LanaRep]/TargetsIgbmc$Ext"] {
scan $Ligne "%s %s" Access ProbeIgbmc
lappend Igbmc($Access) $ProbeIgbmc
lappend LesAccessIgbmc $Access
}
set LesAccessIgbmc [lsort -unique $LesAccessIgbmc]
foreach Ligne [LesLignesDuFichier "[LanaRep]/TargetsMerck$Ext"] {
scan $Ligne "%s %s" Access ProbeMerck
lappend Merck($Access) $ProbeMerck
lappend LesAccessMerck $Access
}
set LesAccessMerck [lsort -unique $LesAccessMerck]
foreach Access $LesAccessMerck {
if {[info exists Igbmc($Access)]} {
AppendAuFichier "[LanaRep]/CommonTargets$Ext" "$Access [join $Igbmc($Access) /] [join $Merck($Access) /]"
}
}
}
proc LanaLocaliseBestHits {IouM {Qui ""}} {
set FichierTargets "[LanaRep]/Targets$IouM"
while {[file exists $FichierTargets]} {
if {[OuiOuNon "Do I replace $FichierTargets"]} { file delete $FichierTargets ; break }
if {[OuiOuNon "Do I cancel LanaLocaliseBestHits"] } { return "" }
}
set Org "Mouse"
if {[regexp "Human" $IouM]} { set Org "Human" }
set Bidon "na -1 na na -1 -1 -1/-1 Plus/Plus -1 -1 -1 -1"
foreach Ligne [LesLignesDuFichier "[LanaRep]/BestHits$IouM"] {
if {$Ligne==""} { continue }
ScanLaListe [split $Bidon " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct
ScanLaListe [split $Ligne " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct
if {$Qui!="" && $Qui!=$Query} { continue }
set Chro $BId
set Milieu [expr ($DebSbjct + $FinSbjct)/2]
set Locs ""
if {$Locs==""} { set Locs [LocIn $Milieu $Org $Chro] }
if {$Locs==""} { set Locs [LocIn $DebSbjct $Org $Chro] }
if {$Locs==""} { set Locs [LocIn $FinSbjct $Org $Chro] }
if {$Locs!=""} {
foreach Loc [split $Locs "\n"] {
ScanLaListe [LesMotsDeLaLigne $Loc] Access Deb Fin Orient
AppendAuFichier $FichierTargets "$Access $Ligne === $Loc"
}
}
}
}
proc LanaBestHits {IouM {Qui ""}} {
set OldBId ""
set OldQuery ""
set Bidon "na -1 na na -1 -1 -1/-1 Plus/Plus -1 -1 -1 -1"
foreach Ligne [LesLignesDuFichier "[LanaRep]/Hits$IouM"] {
if {$Ligne==""} { continue }
ScanLaListe [split $Bidon " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct
ScanLaListe [split $Ligne " "] Query LongQuery BId Access Length Score Expect Identities Strand DebQuery FinQuery DebSbjct FinSbjct
if {$Qui!="" && $Qui!=$Query} { continue }
set QBS [StringSuivant " /" dans $Ligne]
ScanLaListe [split $QBS "/"] SeqQuery Barres SeqSbjct
set DHQ [Mini $DebQuery $FinQuery]
set FHQ [Maxi $DebQuery $FinQuery]
set LHQ [expr $FHQ-$DHQ+1]
if {$FHQ==$LongQuery && ($DHQ==1 || $DHQ==2) && $Identities=="$LHQ/$LHQ"} {
lappend BonsHits($Query) $Ligne
Espionne $Ligne
AppendAuFichier "[LanaRep]/BestHits$IouM" $Ligne
} else {
if { ! [info exists BonsHits($Query)]} {
AppendAuFichier "[LanaRep]/BadHits$IouM" $Ligne
}
}
set OldQuery $Query
continue
#rR le reste est obsolete
ScanLaListe [split $Identities "/"] A B
if {$A<$B} { continue }
if {0 && $Identities!="$LongQuery/$LongQuery"} { continue }
if {[expr $A<$LongQuery-2]} { continue }
if {$OldQuery!=$Query} { Espionne "\n\n[Lana $Query Def]" }
if {0 && $OldBId!=$BId} { Espionne }
set OldBId $BId
Espionne "$Query [format %-5s $BId] $LongQuery $Identities $DebQuery $FinQuery $DebSbjct $FinSbjct $Barres"
}
}
proc LanaHits {IouM} {
set RepDesBla "[LanaRep]/blatblast$IouM"
if {[regexp -nocase "blastn" $IouM]} {
set RepDesBla "[LanaRep]/$IouM"
}
set FichierDesCopains "[LanaRep]/Hits$IouM"
if {[file exists $FichierDesCopains] && [OuiOuNon "Do I replace $FichierDesCopains"]} { file delete $FichierDesCopains }
foreach Fichier [lsort [glob "$RepDesBla/*"]] {
set LesHits [DecortiqueBlat $Fichier]
set LaSortie {}
foreach LeHit $LesHits {
ScanLaListe $LeHit Query LongQuery BId Access Length Score Expect Identities Strand \
DebQuery FinQuery DebSbjct FinSbjct SeqQuery Barres SeqSbjct
set Texte "$Query $LongQuery $BId $Access $Length $Score $Expect $Identities $Strand $DebQuery $FinQuery $DebSbjct $FinSbjct"
append Texte " /$SeqQuery/$Barres/$SeqSbjct"
lappend LaSortie $Texte
}
if {$LaSortie=={}} { continue }
AppendAuFichier $FichierDesCopains [join $LaSortie "\n"]
}
return $FichierDesCopains
}
proc Lana {{Qui ""} {Quoi ""}} {
global Lana
set IouM "Merck"
if {[regexp "^s" $Qui]} { set IouM "Igbmc" }
set FichierTFA "[LanaRep]/nuctfa$IouM/$Qui"
set Entete [EnteteDuFichierTFA $FichierTFA]
if {$IouM=="Igbmc"} {
ScanLaListe [split $Entete " "] SpotID ProductID OligoName GenbankID UGCluster Symbol LLID
set Def [StringSuivant "Def: " dans $Entete]
set Aliases [StringSuivant "Aliases: " dans $Def]
regsub { Aliases: .*} $Def "" Def
} else {
ScanLaListe [split $Entete " "] Reporter_ID gene_id gene locuslink accession
}
set Seq [QueLaSequenceDuFichierTFA $FichierTFA]
if {[info exists $Quoi]} { return [set $Quoi] }
return ""
}
proc LanaRep {} {
return "/genomics/link/Lana"
}
proc LanaLesEtapesPossibles {} {
set LesEtapesPossibles {}
foreach Ligne [split [info body LanaLaTotale] "\n"] {
if { ! [regexp -nocase {\$Etape==\"([a-z_0-9]+)\"} $Ligne Match Etape]} { continue }
lappend LesEtapesPossibles $Etape
}
return $LesEtapesPossibles
}
proc LanaLaTotale {{Etape ""}} {
Wup "Il y a deux fichier Excel Igbmc et Merck sauves en .csv"
Wup "On cree les nuctfa, on fait les blat, on decortique les blat pour creer les copains, on cree les .csv resultat"
if {$Etape==""} { set Etape [ChoixParmi [LanaLesEtapesPossibles]] }
if {$Etape=="Lana"} {
LanaIgbmc
LanaMerck
# set Etape "BLAT_server"
}
if {$Etape=="BLAT_server"} {
BLAT_server start mouse star6
# set Etape "BLAT_clientPourTousRR"
}
if {$Etape=="BLAT_clientPourTousRR"} {
BLAT_clientPourTousRR "[LanaRep]/nuctfaIgbmc" "[LanaRep]/blatblastIgbmc" mouse
BLAT_clientPourTousRR "[LanaRep]/nuctfaMerck" "[LanaRep]/blatblastMerck" mouse
# set Etape "LanaHits"
}
if {$Etape=="LanaHits"} {
LanaHits "Igbmc"
LanaHits "Merck"
# set Etape "LanaBestHits"
}
if {$Etape=="LanaBestHits"} {
LanaBestHits "Igbmc"
LanaBestHits "Merck"
# set set Etape "LanaLocaliseBestHits"
}
if {$Etape=="LanaLocaliseBestHits"} {
LanaLocaliseBestHits Igbmc
LanaLocaliseBestHits Merck
LanaCommonTargets
# set Etape "LanaCreateNuctfaBad"
}
if {$Etape=="LanaCreateNuctfaBad"} {
LanaCreateBadNuctfa "Igbmc" "[LanaRep]/BadHitsIgbmc" "[LanaRep]/nuctfaIgbmcBad"
LanaCreateBadNuctfa "Merck" "[LanaRep]/BadHitsMerck" "[LanaRep]/nuctfaMerckBad"
# set Etape "BLAT_clientPourTousRR-desBadsurHuman"
}
if {$Etape=="BLAT_clientPourTousRR_desBadsurHuman"} {
set RepIgbmcHuman "[LanaRep]/blatblastIgbmcHuman" ; if {[FileAbsent $RepIgbmcHuman]} { file mkdir $RepIgbmcHuman }
BLAT_clientPourTousRR "[LanaRep]/nuctfaIgbmcBad" $RepIgbmcHuman human
# il faut faire find . -size 0 -exec rm {} \;
set RepMerckHuman "[LanaRep]/blatblastMerckHuman" ; if {[FileAbsent $RepMerckHuman]} { file mkdir $RepMerckHuman }
BLAT_clientPourTousRR "[LanaRep]/nuctfaMerckBad" "[LanaRep]/blatblastMerckHuman" human
# il faut faire find . -size 0 -exec rm {} \;
set Etape "LanaHitsHuman"
}
if {$Etape=="LanaHitsHuman"} {
LanaHits "IgbmcHuman"
LanaHits "MerckHuman"
# set Etape "LanaBestHitsHuman"
}
if {$Etape=="LanaBestHitsHuman"} {
LanaBestHits "IgbmcHuman"
LanaBestHits "MerckHuman"
# set Etape "LanaLocaliseBestHitsHuman"
}
if {$Etape=="LanaLocaliseBestHitsHuman"} {
LanaLocaliseBestHits IgbmcHuman
LanaLocaliseBestHits MerckHuman
LanaCommonTargets Human
}
if {$Etape=="LanaBlastN"} {
set RepQuery "[LanaRep]/nuctfaIgbmcBad"
set LesQuery {}
foreach Query [glob -nocomplain "[LanaRep]/nuctfaIgbmcBad/*"] {
set Query [file tail $Query]
lappend LesQuery $Query
}
BlastNPourTous Mus_musculus $LesQuery $RepQuery F 1
set RepBlastNIgbmc "[LanaRep]/blastnIgbmc"
if {[FileAbsent $RepBlastNIgbmc]} {file mkdir $RepBlastNIgbmc}
foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/blastnMus_musculus/*"] {
set Queue [file tail $Fichier]
if { ! [regexp {^s[0-9]+$} $Queue]} { continue }
file copy $Fichier "$RepBlastNIgbmc/$Queue"
}
set RepQuery "[LanaRep]/nuctfaMerckBad"
set LesQuery {}
foreach Query [glob -nocomplain "[LanaRep]/nuctfaMerckBad/*"] {
set Query [file tail $Query]
lappend LesQuery $Query
}
BlastNPourTous Mus_musculus $LesQuery $RepQuery F 1
set RepBlastNMerck "[LanaRep]/blastnMerck"
if {[FileAbsent $RepBlastNMerck]} {file mkdir $RepBlastNMerck}
foreach Fichier [glob -nocomplain "[RepertoireDugenome]/blastnMus_musculus/*"] {
set Queue [file tail $Fichier]
if { ! [regexp {^[0-9]+$} $Queue]} { continue }
file copy $Fichier "$RepBlastNMerck/$Queue"
}
# set Etape "LanaHitsBlastN"
}
if {$Etape=="LanaHitsBlastN"} {
LanaHits "blastnIgbmc"
LanaHits "blastnMerck"
# set Etape "LanaBestHitsBlastN"
}
if {$Etape=="LanaBestHitsBlastN"} {
LanaBestHits "blastnIgbmc"
LanaBestHits "blastnMerck"
}
}
proc LanaCreateBadNuctfa {IouM FromFile ToRep} {
if {[FileAbsent $ToRep ]} { file mkdir $ToRep }
foreach Ligne [LesLignesDuFichier $FromFile] {
scan $Ligne "%s" Query
file copy -force "[LanaRep]/nuctfa$IouM/$Query" "$ToRep/$Query"
}
return $ToRep
}
proc LanaMerck {} {
# Reporter_ID Sequence reporter_id gene_id gene locuslink accession
set RepNuc "[LanaRep]/nuctfaMerck"
if {[FileAbsent $RepNuc]} { file mkdir $RepNuc }
set FichierMerck "[LanaRep]/DeLana/puceOligoSourisMerck.csv"
set Queue [file tail $FichierMerck]
regsub -nocase {\.[^\.]+$} $Queue "" Queue
LoadTxl $FichierMerck T -1 ";"
set LesHeaders $T(ListHeaderPlease,$Queue)
Espionne $LesHeaders
foreach I $T(ListAllPlease,$Queue) {
foreach Header $LesHeaders {
set $Header [string trim $T($I,$Header)]
if {[set $Header]==""} { set $Header "na" }
}
if {$Sequence=="na"} { continue }
regsub -all {\|+} "|$accession|" "|" accession
set Entete "$Reporter_ID $gene_id $gene $locuslink $accession"
set TFA [SequenceFormatTFA $Sequence $Entete "nucbrut"]
set FichierTFA "$RepNuc/$Reporter_ID"
Sauve $TFA dans $FichierTFA
if {$I%100==0} { Espionne $Entete }
}
}
proc LanaIgbmc {} {
# SpotID ProductID OligoName GenbankID Position Sequence Length Tm_C UGCluster Name Symbol Aliases LLID
set FichierIgbmc "[LanaRep]/DeLana/puceOligoSourisIGBMC.csv"
set Queue [file tail $FichierIgbmc]
regsub -nocase {\.[^\.]+$} $Queue "" Queue
LoadTxl $FichierIgbmc T -1 ";"
set RepNuc "[LanaRep]/nuctfaIgbmc"
if {[FileAbsent $RepNuc]} { file mkdir $RepNuc }
set LesHeaders $T(ListHeaderPlease,$Queue)
Espionne $LesHeaders
foreach I $T(ListAllPlease,$Queue) {
foreach Header $LesHeaders {
set $Header [string trim $T($I,$Header)]
if {$Header!="Name" && $Header!="Aliases"} { regsub -all " " [set $Header] "_" $Header }
if {[set $Header]==""} { set $Header "na" }
}
regsub -all " " $LLID "" LLID
regsub {s0*} $SpotID "" SpotNum
regsub -all {\|+} $Aliases "|" Aliases
set Entete "$SpotID $ProductID $OligoName $GenbankID $UGCluster $Symbol $LLID Def: $Name Aliases: $Aliases"
#rR attention on enleve le 1er a
set Sequence [string range $Sequence 1 end]
set TFA [SequenceFormatTFA $Sequence $Entete "nucbrut"]
set FichierTFA "$RepNuc/$SpotID"
Sauve $TFA dans $FichierTFA
if {$I%100==0} { Espionne $Entete }
}
}
proc TesteDoublon {} {
foreach Ligne [LesLignesDuFichier LesDoublons.fof] {
scan $Ligne "%s %s" Ps Fic
regsub "/rng313.forAnnot/" $Fic "/xenoAovFDR.35/" Fix
Espionne $Fic
if {[ContenuDuFichier $Fic]!=[ContenuDuFichier $Fix]} { Espionne "$Fic\n$Fix" }
}
}
proc MenageU133 {{StartPAB ""}} {
if {$StartPAB==""} {
set StartPAB [Entre "zzz please enter the [PreFixe] where I start to clean ..."]
}
foreach Nom [ListeDesPABs] {
if {$Nom<$StartPAB} { continue }
if { ! [OuiOuNonMemo "Do I really clean from $StartPAB"]} { return "" }
foreach Fichier [glob -nocomplain [RepertoireDuGenome]/*/$Nom] {
Espionne $Fichier
file delete $Fichier
}
continue
foreach Fiche [glob -nocomplain [RepertoireDuGenome]/fiches/*] {
if { ! [regexp $Nom [ContenuDuFichier $Fiche]]} { continue }
Espionne $Fiche
}
continue
}
}
proc DoubleFof {} {
set I 0
foreach Ligne [LesLignesDuFichier U133p2.fof.200610191217] {
incr I
scan $Ligne "%s %s" Ps Fi
if {[EstUnPAB [file tail $Fi]]} {
lappend LeBon $Ligne
continue
}
if {[info exists DejaVu($Ps)]} {
Espionne "\n$I\n$DejaVu($Ps)\n$Ligne"
if {[file tail $Fi]!=[file tail $DejaVu($Ps)]} { FaireLire coucou }
lappend LeMauvais $Ligne
} else {
lappend LeBon $Ligne
}
set DejaVu($Ps) $Fi
}
SauveLesLignes $LeBon dans LeNouveauBon2.fof
SauveLesLignes $LeMauvais dans LesDoublons2.fof
exit
}
proc CorrigeU133 {{Rep ""}} {
foreach Fichier [glob "[RepertoireDuGenome]/$Rep/FASTA_NM/*"] {
set Queue [file tail $Fichier]
Espionne $Queue
if {[regexp {[A-Z]+[0-9]+_} $Queue Match]} {
regsub $Match $Queue "" PS
regsub "_$" $Match "" Access
Espionne $PS
lappend LeFOF "$PS $Fichier"
set TFA [ContenuDuFichier $Fichier]
if {[regexp "ID " $TFA]} {
set TFA [SequenceFormatTFA $TFA "" "embl"]
regsub ">" $TFA ">$PS " TFA
Espionne "coucou"
Espionne $TFA
Sauve $TFA dans $Fichier
} else {
set Entete [EnteteDuTexteTFA $TFA]
set Seq [QueLaSequenceDuTexteTFA $TFA]
set I -1
set LesMots [LesMotsDeLaLigne $Entete]
set LeChoix {}
while {[incr I]<4} {
set Choix [join [lrange $LesMots $I end] " "]
lappend LeChoix $Choix
}
set BelleEntete "$PS [ChoixParmi $LeChoix] from $Access"
set TFA [SequenceFormatTFA $Seq $BelleEntete "nucbrut"]
Espionne $TFA
Sauve $TFA dans $Fichier
}
} else {
regexp {([A-Z]+_[0-9]+)_(.+)} $Queue Match Acc PS
lappend LeFOF "$PS $Fichier"
continue
Espionne "$Queue $Acc $PS"
set TFA [ContenuDuFichier $Fichier]
Espionne $TFA
regsub {>[^ ]+ } $TFA ">$PS $Acc " TFA
Espionne $TFA
Sauve $TFA dans $Fichier
}
}
SauveLesLignes $LeFOF dans lefof.fof
return $LeFOF
}
proc CorrigeMGU {} {
foreach Fichier [glob "/genomics/link/MGU4302/ngn3_644gbForAnnot/AllFasta/*"] {
set Queue [file tail $Fichier]
if {[regexp {[A-Z]+[0-9]+_} $Queue Match]} {
regsub $Match $Queue "" PS
lappend LeFOF "$PS $Fichier"
continue
set TFA [ContenuDuFichier $Fichier]
if {[regexp "ID " $TFA]} {
set TFA [SequenceFormatTFA $TFA "" "embl"]
regsub ">" $TFA ">$PS " TFA
Sauve $TFA dans $Fichier
} else {
Espionne $TFA
scan $TFA "%s %s %s" A PSV merde
regsub -all {\|} $merde {\\|} merde
set PS [string trim $PSV ","]
regsub ">" $A "" Acc
regsub "$A $PSV $merde" $TFA ">$PS $Acc" TFA
Espionne $TFA
Sauve $TFA dans $Fichier
}
} else {
regexp {([A-Z]+_[0-9]+)_(.+)} $Queue Match Acc PS
lappend LeFOF "$PS $Fichier"
continue
Espionne "$Queue $Acc $PS"
set TFA [ContenuDuFichier $Fichier]
Espionne $TFA
regsub {>[^ ]+ } $TFA ">$PS $Acc " TFA
Espionne $TFA
Sauve $TFA dans $Fichier
}
}
SauveLesLignes $LeFOF dans lefof.fof
}
proc InformeMGU4302 {} {
foreach Ligne [LesLignesDuFichier [RepertoireDuGenome]/MGU4302.fof] Nom [ListeDesPABs] {
scan $Ligne "%s %s" PS F
set Queue [file tail $F]
regsub "_$PS$" $Queue "" Acc
InformeSansDemander $Nom "Alias: $PS"
InformeSansDemander $Nom "Probeset: $PS"
InformeSansDemander $Nom "Acc: $Acc"
}
}
proc CorrigeInfosU33p2 {} {
foreach Nom [ListeDesPABs] {
set X [ExtraitInfo $Nom "OwnerOfCDNA"]
if {[regexp {([0-9])_([0-9])} $X Match C1 C2]} {
regsub $Match $X "$C1 $C2" AcPs
}
scan $AcPs "%s %s" Ac Ps
set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom nuctfa]]
set TFA [SequenceFormatTFA $Seq "$Nom Homo sapiens Chip U133p2 Probeset $Ps from $Ac"]
Espionne "$Nom $X $Ac $Ps"
Espionne $TFA
InformeSansDemander $Nom "OriginalAc: $Ac"
InformeSansDemander $Nom "OriginalPs: $Ps"
InformeSansDemander $Nom "Alias: $Ps"
Sauve $TFA dans [GscopeFile $Nom nuctfa]
}
}
proc XenoGreffe {{FichierAccessProbeset ""}} {
if {$FichierAccessProbeset==""} { set FichierAccessProbeset [ButineArborescence "all" "[RepertoireDuGenome]/"] }
set NewRep [file tail $FichierAccessProbeset]
regsub {\.txt} $NewRep "" NewRep
if {[FileAbsent "[RepertoireDuGenome]/$NewRep"]} { file mkdir "[RepertoireDuGenome]/$NewRep" }
if {[FileAbsent "[RepertoireDuGenome]/$NewRep/FASTA_NM"]} { file mkdir "[RepertoireDuGenome]/$NewRep/FASTA_NM" }
if {[FileAbsent "[RepertoireDuGenome]/$NewRep/FASTA"]} { file mkdir "[RepertoireDuGenome]/$NewRep/FASTA" }
if {[FileAbsent "[RepertoireDuGenome]/$NewRep/EMBL"]} { file mkdir "[RepertoireDuGenome]/$NewRep/EMBL" }
set LesIntrouvables {}
set LesBons {}
foreach Ligne [LesLignesDuFichier $FichierAccessProbeset] {
scan $Ligne "%s %s" NM PS
set NmPs "${NM}_$PS"
set Trouve 0
foreach Rep [list "FASTA_NM" "FASTA" "EMBL"] {
set Fic "[RepertoireDuGenome]/$NewRep/$Rep/$NmPs"
if {[FileExists $Fic]} {
lappend LesBons $Fic
Espionne $Fic
set Trouve 1
continue
}
}
if {$Trouve} { continue }
set LesLignesEMBL [LaSequenceDesBanques $NM]
EspionneL $LesLignesEMBL
if {$LesLignesEMBL!={}} {
SauveLesLignes $LesLignesEMBL dans "[RepertoireDuGenome]/$NewRep/FASTA_NM/${NM}_$PS"
Espionne "$NM $PS recupere pour FASTA_NM"
continue
}
Espionne "$NM $PS est introuvable"
lappend LesIntrouvables "$NM $PS est introuvable"
}
SauveLesLignes $LesIntrouvables dans "[RepertoireDuGenome]/$NewRep/LesIntrouvables.txt"
foreach Fic $LesBons {
Espionne $Fic
set Queue [file tail $Fic]
set Rep [file tail [file dirname $Fic]]
set TFA ""
if {$Rep=="FASTA" || $Rep=="FASTA_NM"} {
set Seq [QueLaSequenceDuFichierTFA $Fic]
set TFA [SequenceFormatTFA $Seq "$Queue" "nucbrut"]
}
if {$Rep=="EMBL"} {
set TFA [SequenceFormatTFA [ContenuDuFichier $Fic] "$Queue" "embl"]
}
Espionne [Sauve $TFA dans "[RepertoireDuGenome]/$NewRep/nuctfaOri/$Queue"]
}
}
proc XenoGreffe22 {} {
foreach Ligne [LesLignesDuFichier 22.txt] {
scan $Ligne "%s %s" NM PS
set LesLignesEMBL [LaSequenceDesBanques $NM "" a "OnVeutEMBL"]
Espionne "$NM $PS"
if {$LesLignesEMBL!=""} {
SauveLesLignes $LesLignesEMBL dans "[RepertoireDuGenome]/XenoGreffeEMBL/${NM}_$PS"
} else {
set TFA [EntreTexte $NM]
Sauve $TFA dans "[RepertoireDuGenome]/XenoGreffeFASTA/${NM}_$PS"
}
}
}
proc InformeGeneNameForPerox Selection {
if {[regexp "\n" $Selection]} {
foreach Sel [split $Selection "\n"] {
InformeGeneNameForPerox $Sel
}
return
}
scan $Selection "%s" Nom
set Possible [string trim [StringSuivant $Nom dans $Selection]]
if {$Possible==""} { return "" }
return [Informe $Nom "ValiGN: $Possible"]
}
proc SetGeneNameForPerox {} {
foreach Nom [ListeDesPABs] {
set Fichier "[RepertoireDuGenome]/prottfa/$Nom"
if { ! [file exists $Fichier]} { continue }
set Entete [EnteteDuFichierTFA $Fichier]
set D 0
set LesPossibles {}
while {[regexp -start $D -indices {\([^ ]+\)} $Entete Indices]} {
scan $Indices "%d %d" D F
set Match [string range $Entete [expr $D+1] [expr $F-1]]
incr D
if {[string length $Match]< 2} { continue }
if {[string length $Match]>12} { continue }
if {[regexp -nocase {[^0-9a-z\-]} $Match]} { continue }
if {[regexp -nocase {^[0-9]+kD$} $Match]} { continue }
lappend LesPossibles $Match
}
lappend LeTout "$Nom $LesPossibles"
}
set Tout [join $LeTout "\n"]
set Fenetre [AfficheVariable $Tout "" PossibleGenNames]
BoutonneLaFenetre $Fenetre "InformeWithSelection" "InformeGeneNameForPerox \[selection get\]"
}
proc CreeLesSynthetases {Fichier Destination {AA ""} {AAOrig ""}} {
if {$AA==""} {
set AA3 [AADuNomDuFichier $Fichier "AvecAlias"]
set AA3Orig [AADuNomDuFichier $Fichier "SansAlias"]
set AA1 [UT $AA3Orig]
} else {
set AA3 $AA
if {$AAOrig==""} {
set AA3Orig $AA3
} else {
set AA3Orig $AAOrig
}
set AA1 [UT $AA3Orig]
}
set Nom [file tail $Fichier]
Glossaire Pour init
set DejaVuUn 0
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp "Name:" $Ligne]} {
if {$DejaVuUn} { break } else { continue }
}
set DejaVuUn 1
scan $Ligne "%s %s" Name Access
if { ! [regexp -nocase "^hmr_" $Access] && [file exists "$Destination/$Access"]} { continue }
if {[regexp -nocase "^sy" $Access]} {
set LesLignesEMBL [LaSequenceDesBanques "sw:$Access" "$Access" AccessOK "OnVeutEMBL"]
if {[llength $LesLignesEMBL]>0} {
Espionne [SauveLesLignes $LesLignesEMBL dans "$Destination/$Access"]
continue
}
}
set Hmr ""
set AccessDansMSF $Access
if {[regexp -nocase "hmr_" $Access Hmr]} {
set Access [string range $AccessDansMSF 4 end]
}
if {[regexp {^[a-zA-Z]+_[a-zA-Z]+} $Access]} {
set LesMots [split $Access "_"]
set Gen [lindex $LesMots 0]
set Esp [lindex $LesMots 1]
regsub {[0-9]} $Esp "" Esp
if {[llength $LesMots] > 2} {
set Extension "_[join [lrange $LesMots 2 end] "_"]"
} else {
set Extension ""
}
set Organisme [OrgApprochant $Gen $Esp]
set Sequence [UneSequenceDuMSF $Fichier $AccessDansMSF]
set Sequence [Scrunch $Sequence]
Espionne [SauveLesLignes [CreeUnFichierEMBL $AA3 $Organisme "$Hmr$AA1" $Sequence $Extension]\
dans "$Destination/$Hmr$Access"]
continue
}
continue
if {[regexp {^ai|^gi} $Access]} {
set Pep [glob -nocomplain /home/moumou/hmr/*/$Access.pep]
set LePep [LesLignesDuFichier $Pep]
set Entete ""
foreach Lig [lrange $LePep 1 end] {
if { ! [regexp {[a-zA-Z]} $Lig]} { break }
append Entete $Lig
}
set Entete [string trim $Entete]
set LesChamps [split $Entete "\["]
set OR ""
set PN ""
set DE ""
set pn ""
set gn ""
foreach Champ $LesChamps {
regsub {\]} $Champ "" Champ
if {[regexp "OR:" $Champ]} {
set OS [string trim [string range $Champ 3 end]]
}
if {[regexp "PN:" $Champ]} {
set PN [string trim [string range $Champ 3 end]]
}
if {[regexp "DE:" $Champ]} {
set DE [string trim [string range $Champ 3 end]]
set LesSousChamps [split $Champ "\("]
foreach SousChamp $LesSousChamps {
regsub {\)} $SousChamp "" SousChamp
if {[regexp "^pn:" $SousChamp]} {
set pn [string trim [string range $SousChamp 3 end]]
}
if {[regexp "^gn:" $SousChamp]} {
set gn [string trim [string range $SousChamp 3 end]]
}
}
if {$pn==""} {
set ipn [string first "pn:" $DE]
if {$ipn>=0} {
set iSuivant [string first ":" [string range $DE [incr ipn 3] end]]
if {$iSuivant<0} {
set fpn "end"
} else {
set fpn [expr $iSuivant -4 +$ipn]
}
set pn [string range $DE $ipn $fpn]
}
}
if {$gn==""} {
set ign [string first "gn:" $DE]
if {$ign>=0} {
set iSuivant [string first ":" [string range $DE [incr ign 3] end]]
if {$iSuivant<0} {
set fgn "end"
} else {
set fgn [expr $iSuivant -4 +$ign]
}
set gn [string range $DE $ign $fgn]
}
}
}
}
set iPP [lsearch -regexp $LePep {\.\.}]
set Sequence [join [lrange $LePep [incr iPP] end] ""]
regsub -all {[0-9\t\n \*]} $Sequence "" Sequence
set Sortie {}
lappend Sortie "ID $Access; cree par rR d'apres $Access de HMR."
lappend Sortie "AC $Access"
if {$PN!=""} {
lappend Sortie "PN $PN"
}
if {$DE!=""} {
lappend Sortie "DE $DE"
if {$pn!=""} {
lappend Sortie "pn $pn"
}
if {$gn!=""} {
lappend Sortie "gn $gn"
}
}
lappend Sortie "OS $OS"
lappend Sortie [QueSequenceFormatEMBL $Sequence "AvecSQ"]
if {$PN=="" && $pn==""} {
Warne ".......Manque PN\n$Entete"
}
Espionne [SauveLesLignes $Sortie dans "$Destination/$Access"]
continue
}
Warne "Je n'ai rien pour $Ligne"
}
}
proc CreeProtTfaPhorDeGenEmbl {} {
Wup "Comme c'etait pas tres clair j'ai pris /genome/P.horikoshii/phori.ref "
Wup " et j'en ai extrait les lignes 'gene debut. .fin'"
Wup " et 'gene complement(debut. .fin)"
set nForwards 0
set nReverses 0
set YaCDS 0
set LesForwards {}
set LesNomsForwards {}
set LesReverses {}
set LesNomsReverses {}
set AuBon ""
foreach Ligne [LesLignesDuFichier "/genome/P.horikoshii/phori.ref"] {
if { [regexp "CDS " $Ligne]} { set YaCDS 1 ; continue }
if {$YaCDS && [regexp "/gene" $Ligne]} { continue }
set YaCDS 0
if {[regexp "/gene" $Ligne]} {
if {$AuBon == ""} { continue }
lappend $AuBon [StringApres "/gene=" dans $Ligne]
if {$DeuxFois} { lappend $AuBon [StringApres "/gene=" dans $Ligne] }
set AuBon ""
}
if { ! [regexp "gene " $Ligne]} { continue }
regsub -all {[^0-9]} $Ligne " " Deux
set DeuxFois 0
if {[regexp "join" $Ligne]} {
set DeuxFois 1
regsub -all {[^0-9]} $Ligne " " Quatre
scan $Quatre "%d %d %d %d" a b c d
if {[regexp "complement" $Ligne]} {
lappend LesReverses "[incr c 3] $d"
incr nReverses
} else {
lappend LesForwards "$c [incr d -3]"
incr nForwards
}
}
scan $Deux "%d %d" a b
if {[regexp "complement" $Ligne]} {
lappend LesReverses "[incr a 3] $b"
incr nReverses
set AuBon "LesNomsReverses"
} else {
lappend LesForwards "$a [incr b -3]"
incr nForwards
set AuBon "LesNomsForwards"
}
}
Espionne $LesNomsForwards
Espionne "[llength $LesForwards] [llength $LesNomsForwards]"
Espionne "[llength $LesReverses] [llength $LesNomsReverses]"
set NumeroF 0
foreach Forward $LesForwards LeurNom $LesNomsForwards {
set Orient "F"
scan $Forward "%d %d" Debut Fin
set BeauNumero [format "%4.4d" [incr NumeroF]]
set Nom "PHOK$BeauNumero"
set EnteteSolo ">$Nom $Debut $Fin $Orient $LeurNom"
set EnteteTous ">PHOR:$Nom $Nom $Debut $Fin $Orient $LeurNom"
set Sequence [SequenceFormatBrut [SeqNucToSeqPro [BoutADN $Debut $Fin $Orient]]]
set TFA "$EnteteSolo\n$Sequence"
Espionne $TFA
lappend BornesDesPABs "$Nom $Debut $Fin $Orient"
lappend ToutTFA "$EnteteTous\n$Sequence"
# Espionne [Sauve $TFA dans "./prottfa/$Nom"]
}
set NumeroR [expr $nForwards+$nReverses+1]
foreach Reverse $LesReverses LeurNom $LesNomsReverses {
set Orient "R"
scan $Forward "%d %d" Debut Fin
set BeauNumero [format "%4.4d" [incr NumeroR -1]]
set Nom "PHOK$BeauNumero"
set EnteteSolo ">$Nom $Debut $Fin $Orient $LeurNom"
set EnteteTous ">PHOR:$Nom $Nom $Debut $Fin $Orient $LeurNom"
set Sequence [SequenceFormatBrut [SeqNucToSeqPro [BoutADN $Debut $Fin $Orient]]]
set TFA "$EnteteSolo\n$Sequence"
Espionne $TFA
lappend BornesDesPABs "$Nom $Debut $Fin $Orient"
lappend ToutTFA "$EnteteTous\n$Sequence"
# Espionne [Sauve $TFA dans "./prottfa/$Nom"]
}
# Espionne [SauveLesLignes $BornesDesPABs dans "./fiches/bornesdespabs"]
# Espionne [SauveLesLignes $ToutTFA dans "./db/proteines.tfa"]
}
proc MobDir {} {
return "[HomeRipp]/Mob"
}
proc MobBinaryPath {} {
set FichierConfig "[MobDir]/core/Local/Config/Config.py"
set Path [StringSuivant "\nBINARY_PATH =" dans [ContenuDuFichier $FichierConfig]]
regsub {\].*} $Path "" Path
regsub -all {[ '\[]} $Path "" Path
set LePath [split $Path ","]
return $LePath
}
proc MobListOfFichierXml {} {
set XmlDir "[MobDir]/core/Services/Programs"
set LesFichierXml [lsort -unique [glob "$XmlDir/*.xml"]]
return $LesFichierXml
}
proc MobListOfCommand {{Qui ""} {Quoi ""}} {
global MobListOfCommand
if {[info exists MobListOfCommand($Qui,$Quoi)]} { return $MobListOfCommand($Qui,$Quoi) }
if {[info exists MobListOfCommand("EstCharge")]} { return "" }
set MobListOfCommand("EstCharge") 1
set LesCommand {}
foreach FicXml [MobListOfFichierXml] {
set CommandFromFic [file tail $FicXml]
regsub ".xml$" $CommandFromFic "" CommandFromFic
set Texte [ContenuDuFichier $FicXml]
set Command [ValeurDeLaBalise "command" Texte "NePasRogner"]
if {$Command == ""} {
set Attribut [AttributsDeLaBalise "parameter" Texte "NePasRogner"]
if {[regexp "iscommand" $Attribut]} {
set ParamCommand [ValeurDeLaBalise "parameter" Texte "NePasRogner"]
set Command [ValeurDeLaBalise "format" ParamCommand "NePasRogner"]
set Command [ValeurDeLaBalise "code" Command "NePasRogner"]
regsub -all "\"" $Command "" Command
set Command [string trim $Command]
set Command [lindex [split $Command " "] 0]
if {[regexp "\\$" $Command] || $Command =="cat" || $Command =="&&"} {
set Command $CommandFromFic
}
} else {
set Command $CommandFromFic
}
}
scan $Command "%s" Command
if {$Command==""} { continue }
lappend MobListOfCommand(ListOf,Command) $Command
set MobListOfCommand($FicXml,Command) $Command
lappend MobListOfCommand($Command,FicXml) $FicXml
}
set MobListOfCommand(ListOf,Command) [lsort -unique [MobListOfCommand ListOf Command]]
return [MobListOfCommand $Qui $Quoi]
}
proc MobListOfEnv {{Qui ""} {Quoi ""}} {
global MobListOfEnv
if {[info exists MobListOfEnv($Qui,$Quoi)]} { return $MobListOfEnv($Qui,$Quoi) }
if {[info exists MobListOfEnv("EstCharge")]} { return "" }
set MobListOfEnv("EstCharge") 1
set LesEnv {}
foreach FicXml [MobListOfFichierXml] {
foreach Ligne [LesLignesDuFichier $FicXml] {
if {![regexp {\<xi\:include href=\"(.*Env/.*\.xml)\"} $Ligne Match EnvXml]} { continue }
set path "[file dirname $FicXml]/$EnvXml"
lappend MobListOfEnv(ListOf,LesEnv) $path
lappend MobListOfEnv($FicXml,Env) $path
lappend MobListOfEnv(ListOf,FicXml) $FicXml
}
}
set MobListOfEnv(ListOf,LesEnv) [lsort -unique [MobListOfEnv ListOf LesEnv]]
set MobListOfEnv(ListOf,FicXml) [lsort -unique [MobListOfEnv ListOf FicXml]]
return [MobListOfEnv $Qui $Quoi]
}
proc MobCheckPrograms {{GetWhat ""}} {
set LeBinaryPath [MobBinaryPath]
foreach P $LeBinaryPath {
foreach FE [glob -nocomplain "$P/*"] {
if { ! [file executable $FE]} { continue }
set E [file tail $FE]
lappend FileOf($E) $FE
}
}
foreach FicXml [MobListOfFichierXml] {
set Program [file tail $FicXml]
regsub ".xml$" $Program "" Program
set C [MobListOfCommand $FicXml Command]
if {[info exists FileOf($C)]} {
if {[llength $FileOf($C)]>1} { lappend LesDoublons "$C $FileOf($C)" }
set Premier [lindex $FileOf($C) 0]
set LesEnv [MobListOfEnv $FicXml Env]
if {$LesEnv==""} {
lappend LePath [file dirname $Premier]
lappend LesBons $Program
}
if {$LesEnv!=""} {
set EnvManquant 0
foreach Env $LesEnv {
if {![file exists $Env]} {set EnvManquant 1}
}
if {!$EnvManquant} {
lappend LePath [file dirname $Premier]
lappend LesBons $Program
} else {
lappend LesManquants $Program
}
}
} else {
lappend LesManquants $Program
}
}
set LePath [lsort -unique $LePath]
set LesManquants [lsort -unique $LesManquants]
set LesBons [lsort -unique $LesBons]
set LesDoublons [lsort -unique $LesDoublons]
if {$GetWhat=="GetPath"} { return $LePath }
if {$GetWhat=="GetManquants"} { return $LesManquants }
if {$GetWhat=="GetBons"} { return $LesBons }
if {$GetWhat=="GetDoublons"} { return $LesDoublons }
if {$GetWhat=="GetAlltogether"} {
set Alltogether [list]
set BB ""; set BS ""
if {[PourWscope]} {
set BB "<b>"; set BS "</b>"
lappend Alltogether "<pre>"
}
lappend Alltogether "\n $BB Pathes $BS\n"
LConcat Alltogether $LePath
lappend Alltogether "\n $BB Binaries $BS\n"
LConcat Alltogether $LesBons
lappend Alltogether "\n $BB Missing Binaries $BS\n"
LConcat Alltogether $LesManquants
lappend Alltogether "\n $BB Ambigious Binaries $BS\n"
LConcat Alltogether $LesDoublons
if {[PourWscope]} {
lappend Alltogether "</pre>"
}
return [join $Alltogether "\n"]
}
AfficheListe $LePath "" "LePath"
AfficheListe $LesManquants "" "LesManquants"
AfficheListe $LesBons "" "LesBons"
AfficheListe $LesDoublons "" "LesDoublons"
Affiche "'[join $LePath {', '}]'" "" "Pathes"
Affiche "'[join $LesManquants {', '}]'" "" "Excludes"
return $LePath
}
proc MobyleDeploy {} {
set LesToDeployP [glob -nocomplain "[MobDir]/core/Services/Programs/*.xml"]
LConcat LesToDeployP [glob -nocomplain "[MobDir]/core/Local/Services/Programs/*.xml"]
set LesToDeployV [glob -nocomplain "[MobDir]/core/Services/Viewers/*.xml"]
LConcat LesToDeployV [glob -nocomplain "[MobDir]/core/Local/Services/Viewers/*.xml"]
set LesToDeployW [glob -nocomplain "[MobDir]/core/Services/Workflows/*.xml"]
LConcat LesToDeployW [glob -nocomplain "[MobDir]/core/Local/Services/Workflows/*.xml"]
foreach Manquant [MobCheckPrograms GetManquants] {
set VerifManquant($Manquant) 1
}
foreach ToDeployP $LesToDeployP {
set P [file tail $ToDeployP]
regsub ".xml$" $P "" P
if {[info exists VerifManquant($P)] && $VerifManquant($P)} { continue }
lappend LesP $P
}
Espionne "[HomeRipp]/Mob/core/Tools/mobdeploy -s local -p [join $LesP ","] deploy"
foreach ToDeployV $LesToDeployV {
set V [file tail $ToDeployV]
regsub ".xml$" $V "" V
lappend LesV $V
}
Espionne "[HomeRipp]/Mob/core/Tools/mobdeploy -s local -v [join $LesV ","] deploy"
foreach ToDeployW $LesToDeployW {
set W [file tail $ToDeployW]
regsub ".xml$" $W "" W
lappend LesW $W
}
Espionne "[HomeRipp]/Mob/core/Tools/mobdeploy -s local -w [join $LesW ","] deploy"
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.