Index by: file name |
procedure name |
procedure call |
annotation
gscope_aligne.tcl
(annotations | original source)
#rR gscope_aligne.tcl
proc LectureSegAli {Access SQ OS SegAli} {
set ListeDesHomologues {}
set StoreConservation 0
set SS ""
foreach Ligne [lrange $SegAli 0 end-2] Ligne2 [lrange $SegAli 1 end-1] Ligne3 [lrange $SegAli 2 end] {
if {0 && $Access=="WP_049995565.1"} { Espionne $Ligne }
if {$StoreConservation} {
append SeqConse [string range $Ligne $D $F]
set StoreConservation 0
}
if {[regexp {Length *= *([0-9]+)} $Ligne Match Length]} {
if {$SS==""} { set SS [string repeat "?" $Length] }
continue
}
if { [regexp "^ Identities =" $Ligne] } {
set Identities [StringApres "Identities =" dans $Ligne]
set Positives [StringApres "Positives =" dans $Ligne]
scan $Identities "%d/%d" nId nTotal
scan $Positives "%d/%d" nPo nTotal
}
if { [regexp "^ Score =" $Ligne] || $Ligne=="FinSegAli" } {
if {[info exists Score]} {
if {[info exists DebutQuery] && [info exists DebutSbjct]} {
incr nCops
incr nCopsDansCetteSequence
set Homologie [list $Access $nCops $nCopsDansCetteSequence $OS $Score $Expect $DebutQuery $FinQuery $DebutSbjct $FinSbjct $SeqQuery $SeqConse $SeqSbjct]
lappend ListeDesHomologues $Homologie
}
unset Score
if { $Ligne=="FinSegAli"} { break }
}
set Score [FloatApres "Score =" dans $Ligne]
if {[regexp "Expect =" $Ligne]} {
set Expect [PNApres "Expect =" dans $Ligne]
}
if {[regexp {Expect\([0-9]\) =} $Ligne Match]} {
set Expect [PNApres $Match dans $Ligne]
}
if { ! [info exists Expect]} {
Warne "$Ligne\nwithout Expect ... I break"
break
}
if {[info exists DebutQuery]} { unset DebutQuery }
if {[info exists DebutSbjct]} { unset DebutSbjct }
#if {[expr $Expect > $SeuilDuBlastN]} { break }
}
if {[regexp "^Query:?" $Ligne] } {
if { ! [info exists DebutQuery]} {
set SeqQuery ""
set KeyQ "Query"
if {[regexp "Query:" $Ligne]} { set KeyQ "Query:" }
set DebutQuery [IntegerApres $KeyQ dans $Ligne]
set SeqConse ""
}
regexp -nocase -indices {^(Query|Sbjct):? +[0-9]+ +([A-Z\-])} $Ligne IndicesDebut
set D [lindex $IndicesDebut 1]
regexp -nocase -indices {([A-Z\-] +[0-9]+) *$} $Ligne IndicesFin
set F [lindex $IndicesFin 0]
regexp -nocase -indices {^(Query|Sbjct):? +[0-9]+ +([A-Z\-])} $Ligne3 IndicesDebut3
set D3 [lindex $IndicesDebut3 1]
regexp -nocase -indices {([A-Z\-] +[0-9]+) *$} $Ligne3 IndicesFin3
set F3 [lindex $IndicesFin3 0]
#rR c'est trop complique ... il faut creer les séquences dans une autre boucle ...
set SeqDeLaLigne [string range $Ligne $D $F]
append SeqQuery $SeqDeLaLigne
set FinQuery [IntegerEnFin de $Ligne]
set StoreConservation 1
regsub -all {\-} $SeqDeLaLigne "" SeqDeLaLigneSansGap
set DQ [expr [IntegerApres $KeyQ dans $Ligne]]
set FQ $FinQuery
set SQ [string replace $SQ [expr $DQ-1] [expr $FQ-1] $SeqDeLaLigneSansGap]
set FinQueryPrevious $FinQuery
}
if {[regexp "^Sbjct:?" $Ligne] } {
if { ! [info exists DebutSbjct]} {
set SeqSbjct ""
set Key "Sbjct"
if {[regexp "Sbjct:" $Ligne]} { set Key "Sbjct:" }
set DebutSbjct [expr [IntegerApres $Key dans $Ligne]] ; #rR y avait aussi + Offset
}
set SeqDeLaLigne [string range $Ligne $D $F]
append SeqSbjct $SeqDeLaLigne
regsub -all {\-} $SeqDeLaLigne "" SeqDeLaLigneSansGap
set FinSbjct [expr [IntegerEnFin de $Ligne]] ; #rR y avait aussi + Offset
set DS [expr [IntegerApres $Key dans $Ligne]]
set FS $FinSbjct
set SS [string replace $SS [expr $DS-1] [expr $FS-1] $SeqDeLaLigneSansGap]
set FinSubjctPrevious $FinSbjct
}
}
if {0 && $Access=="WP_049995565.1"} { EspionneL $ListeDesHomologues ; Espionne $Access}
return [list $SQ $SS $Length $ListeDesHomologues]
}
proc ConcatAlignments {OutFile args} {
set I 0
set LeTotal {}
foreach F $args {
incr I
foreach Ligne [LesLignesDuFichier $F] {
regsub "^>" $Ligne ">${I}_" Ligne
lappend LeTotal $Ligne
}
}
return [SauveLesLignes $LeTotal dans $OutFile]
}
proc OnVireLesMonstresLointains {{Valeur ""}} {
global OnVireLesMonstresLointains
if {$Valeur!=""} { return [set OnVireLesMonstresLointains $Valeur] }
if {[info exists OnVireLesMonstresLointains]} { return $OnVireLesMonstresLointains }
set OnVireLesMonstresLointains 0
return $OnVireLesMonstresLointains
}
proc MacsimExiste {} {
return [file exists "[RepertoireDuGenome]/macsimXml"]
}
proc LesGrosManquants {} {
foreach Nom [ListeDesPABs] {
set FichierMsf "[RepertoireDuGenome]/msf/$Nom"
set FichierLeo "[RepertoireDuGenome]/msfLeon/$Nom"
set FichierRsf "[RepertoireDuGenome]/macsimRsf/$Nom"
set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
if {[file exists $FichierRsf]} { continue }
if { ! [file exists $FichierMsf]} { continue }
Espionne "$Nom [file exists $FichierLeo] [file exists $FichierRsf] [file size $FichierMsf]"
}
exit
}
proc MAFFTPourTous {{RepTFAs ""} {RepMAFFT ""} {Keep ""}} {
if {$Keep=="OverWrite"} { set Keep 0 }
if {$Keep=="Keep"} { set Keep 1 }
if {$Keep==""} { set Keep [OuiOuNon "Do I keep existing files ?"] }
if {$RepTFAs==""} { set RepTFAs "[RepertoireDuGenome]/tfaspourmafft" }
if {$RepMAFFT==""} { set RepMAFFT "[RepertoireDuGenome]/mafft" }
if { ! [file exists $RepMAFFT]} { file mkdir $RepMAFFT }
foreach Nom [ListeDesPABs] {
set FichierTFAs "$RepTFAs/$Nom"
if { ! [file exists $FichierTFAs]} { continue }
set FichierMAFFT "$RepMAFFT/$Nom"
if {$Keep && [file exists $FichierMAFFT]} { continue }
set Retour [MAFFT $FichierTFAs $FichierMAFFT]
Espionne "I run MAFFT on $Nom and got >$Retour<"
}
}
proc MAFFT {FichierTFAs {FichierMAFFT ""}} {
if {$FichierMAFFT==""} {
regsub {\.tfa(|s)$} $FichierTFAs "" FichierMAFFT
append FichierMAFFT ".mafft"
}
set VraiFichierTFAs $FichierTFAs
if { ! [regexp "^/" $FichierTFAs]} { set VraiFichierTFAs "[pwd]/$FichierTFAs" }
set VraiFichierMAFFT $FichierMAFFT
if { ! [regexp "^/" $FichierMAFFT]} { set VraiFichierMAFFT "[pwd]/$FichierMAFFT" }
NousAllonsAuBoulot
set RepDessus [pwd]
set RepMAFFT "[TmpFile MAFFT .]"
file mkdir $RepMAFFT
cd $RepMAFFT
set Racine [file tail $VraiFichierTFAs]
file copy $VraiFichierTFAs $Racine.in
set OK 1
while 1 {
if {[catch { exec /biolo/mafft/bin/sextet5 < $Racine.in >& /dev/null } Message]} {
FaireLire "MAFFT failed running 'sextet5' with message \n$Message"
set OK 0
break
}
if {[catch { exec /biolo/mafft/bin/tbfast -FAx < $Racine.in >& /dev/null } Message]} {
FaireLire "MAFFT failed running 'tbfast -FAx ...' with message \n$Message"
set OK 0
break
}
if {[catch { exec /biolo/mafft/bin/tbfast -JFAx < pre > $Racine.out 2> $Racine.log } Message]} {
FaireLire "MAFFT failed running 'tbfast -JFAx ...' with message \n$Message"
set OK 0
break
}
break
}
if { $OK } {
if {[file exists $Racine.out]} { file rename -force $Racine.out $VraiFichierMAFFT }
cd $RepDessus
foreach F [glob -nocomplain $RepMAFFT/*] {
file delete -force $F
}
file delete $RepMAFFT
}
OnRevientDuBoulot
if { ! $OK } { return "" }
return [ConvertToMsf $FichierMAFFT $FichierMAFFT]
}
proc ExecuteMacsim {FichierMsf FichierRsf} {
Wup "On retourne vide si ca se passe bien, Message d'erreur si non"
# exec /biolo/macsim/macsim $FichierMsf $FichierRsf
set Nom [file tail $FichierMsf]
regsub {\..*} $Nom "" Nom
if {$Nom=="HSAP08771"} {
Espionne "ExecuteMacsim $FichierMsf $FichierRsf \nen [pwd]"
set RepTest "/genomics/link/CilioCarta/test"
if {[catch {exec $RepTest/mon_macsim $FichierMsf $FichierRsf >& $RepTest/$Nom.log } Message]} {
return $Message
}
return ""
}
Espionne "/biolo/macsim/macsim $FichierMsf $FichierRsf"
if {[catch {exec /biolo/macsim/macsim $FichierMsf $FichierRsf >& /dev/null } Message]} { return $Message }
return ""
}
proc LeonEtMacsimPourTous {{Liste ""} {Keep ""} {SqueezeLeon ""}} {
set SqueezeLeon [string equal -nocase $SqueezeLeon "SqueezeLeon"]
set RepLeo "[RepertoireDuGenome]/msfLeon"
set RepLog "[RepertoireDuGenome]/leonLog"
set RepRsf "[RepertoireDuGenome]/macsimRsf"
set RepXml "[RepertoireDuGenome]/macsimXml"
if {$SqueezeLeon} {
set RepLeo "[RepertoireDuGenome]/msf"
}
if { ! [file exists $RepLeo]} {file mkdir $RepLeo}
if { ! [file exists $RepLog]} {file mkdir $RepLog}
if { ! [file exists $RepRsf]} {file mkdir $RepRsf}
if { ! [file exists $RepXml]} {file mkdir $RepXml}
if {$Keep==""} { set Keep "Keep" }
if {$Keep=="Keep"} { set Keep 1 } else { set Keep 0 }
if {[regexp "^StartWith" $Liste]} {
set Premier [StringApres "StartWith" dans $Liste]
set Liste [ListeDesPABs]
set I [lsearch $Liste $Premier]
set Liste [lrange $Liste $I end]
} else {
if {$Liste==""} { set Liste [ListeDesPABs] }
if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
}
foreach Nom $Liste {
Espionne "LeonEtMacsim s'occupent de $Nom"
set FichierMSF "[RepertoireDuGenome]/msf/$Nom"
if { ! [file exists $FichierMSF]} { continue }
if {[file size $FichierMSF] < 50} { continue }
set FichierLeo "$RepLeo/$Nom"
set FichierLog "$RepLog/$Nom"
set FichierRsf "$RepRsf/$Nom"
set FichierXml "$RepXml/$Nom"
set TexteMsf [ContenuDuFichier $FichierMSF]
set Query $Nom
if {[regexp "QUERY_PROTEIN" $TexteMsf]} {
set Query "QUERY_PROTEIN"
}
if { ! [regexp "Name: $Query" $TexteMsf]} {
if { ! [regexp { Name: ([^ ]+)} $TexteMsf Match BetterQuery]} {
set MonMessge "I can't find the query in $FichierMSF\nI'll skip"
append MonMessage "\n$FichierLeo was not created by Leon ... Bouhhh !"
AppendAuFichier $FichierLog $MonMessage
Warne $MonMessage
continue
}
Warne "I choose the first access $Query as query."
set Query $BetterQuery
}
regsub ".rsf$" $FichierRsf "" FichierRsfSansExtension
if { $Keep && [file exists $FichierRsfSansExtension]} { continue }
if { $Keep && [file exists $FichierRsf]} { continue }
if {[PasTouche $Nom]} { continue }
set CommandeLeon "leonbis" ; #rR depuis 2017/09/18 **************************
set OnTeste [OnTraite "TestUniref"]
if {0 && $OnTeste} { set CommandeLeon "/home/julie/LEON2/leon2.tcsh" }
if { ! [file exists $FichierLeo]} {
if {[file exists $FichierLog]} { file delete $FichierLog }
set FichierLeoXml $FichierLeo.xml
if {[file exists $FichierLeoXml]} { file delete $FichierLeoXml }
Espionne "$CommandeLeon $FichierMSF $Query $FichierLeo $FichierLog"
exec $CommandeLeon $FichierMSF $Query $FichierLeo $FichierLog
}
if {[file exists $FichierXml]} { file delete $FichierXml }
if {[file exists $FichierRsf]} { file delete $FichierRsf }
if { ! [file exists $FichierLeo]} {
set MonMessage "$FichierLeo was not created by Leon ... Bouhhh !"
AppendAuFichier $FichierLog $MonMessage
Warne $MonMessage
FinPasTouche $Nom
continue
}
ConvertToOneHundred $FichierLeo $FichierLeo
if { ! $OnTeste } {
NousAllonsAuBoulot
set FichierRsfLog "$FichierRsf.log"
if {[file exists $FichierRsfLog]} {file delete $FichierRsfLog}
Espionne "ExecuteMacsim $FichierLeo $FichierRsf"
set Message [ExecuteMacsim $FichierLeo $FichierRsf]
OnRevientDuBoulot
set FichierRsfRsf "$FichierRsf.rsf"
set FichierRsfXml "$FichierRsf.xml"
if {[file exists $FichierRsfXml]} {
file rename -force $FichierRsfXml $FichierXml
}
if { ! [file exists $FichierRsfRsf]} {
set MonMessage "$FichierRsfRsf was not created. I got the message\n$Message"
Warne $MonMessage
AppendAuFichier $FichierRsfLog $MonMessage
} else {
file rename -force $FichierRsfRsf $FichierRsf
if {[file exists $FichierRsfLog]} { file delete $FichierRsfLog }
Espionne "$FichierRsf is OK !"
}
}
FinPasTouche $Nom
}
}
proc TailleDesSequencesAAligner {{Liste ""}} {
set EnDetails 0
if {$Liste==""} { set Liste [ListeDesPABs] }
if {[EstUnPAB $Liste]} {
set EnDetails 1
set Liste [list $Liste]
set LesLongueursAccess {}
}
foreach Nom $Liste {
set Fichier "[RepertoireDuGenome]/tfasdescopains/$Nom"
if { ! [file exists $Fichier]} { continue }
set MinLong 999999
set MaxLong 0
set LesLongueurs {}
foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $Fichier $Access]
set Long [string length [QueLaSequenceDuTexteTFA $TFA]]
lappend LesLongueurs $Long
if {$EnDetails} {
set Entete [EnteteDuTexteTFA $TFA]
lappend LesLongueursAccess "$Long $Entete"
}
set MinLong [Mini $MinLong $Long]
set MaxLong [Maxi $MaxLong $Long]
}
set LesLongueurs [lsort -integer $LesLongueurs]
if {$EnDetails} {
set LesLongueursAccess [lsort -index 0 -integer $LesLongueursAccess]
return [AfficheVariable [join $LesLongueursAccess "\n"] \
"AvecFetch" "SequenceLengthesOf/$Fichier"]
}
if {$MaxLong<1000} { continue }
lappend ToutesLesLongueurs "$Nom $MaxLong"
}
if {$EnDetails} { exit }
set ToutesLesLongueurs [lsort -index 1 -integer $ToutesLesLongueurs]
SauveLesLignes $ToutesLesLongueurs dans "[RepertoireDuGenome]/fiches/toutesleslongueurs"
exit
}
proc ConserveLesDomaines {FichierMSF FichierBornes Ref NouveauFichierMSF} {
global TmpTFAsDuMSFMemo NomDuFichierMSFMemo
if {[info exists TFAsDuMSFMemo] && $NomDuFichierMSFMemo==$FichierMSF} {
set TmpTFA $TmpTFAsDuMSFMemo
} else {
set TFAs [CreeLeTFAsDuMSF $FichierMSF]
set TmpTFAs [Sauve $TFAs dans [TmpFile]]
set TmpTFAsDuMSFMemo $TmpTFAs
set NomDuFichierMSFMemo $FichierMSF
}
set LesBornesGlobales {}
set LesBornesDesManquants [list 1]
foreach Ligne [LesLignesDuFichier $FichierBornes] {
if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
scan $Ligne "%d %d" D F
set DG [PositionDansMSF Global $FichierMSF $D $Ref]
set FG [PositionDansMSF Global $FichierMSF $F $Ref]
Espionne "$DG $FG"
lappend LesBornesDesManquants [expr $DG-1]
lappend LesBornesDesManquants [expr $FG+1]
lappend LesBornesGlobales $DG $FG
}
lappend LesBornesDesManquants "end"
if {[file exists bornes_des_manquants]} { file delete bornes_des_manquants }
foreach {A B} $LesBornesDesManquants {
AppendAuFichier bornes_des_manquants "$A $B"
}
foreach Access [LaSequenceDuTFAs $TmpTFAs LaListeDesAccess] {
set Seq [QueLaSequenceDuTexteTFA [LaSequenceDuTFAs $TmpTFAs $Access]]
# regsub -all {\.} $Seq "-" Seq
set LesZones {}
foreach {D F} $LesBornesGlobales {
set Zone [string range "x$Seq" $D $F]
Espionne "$D $F $Zone"
lappend LesZones $Zone
}
set NouvSeq [join $LesZones "-"]
set NouvTFA [SequenceFormatTFA $NouvSeq "$Access" "protbrut"]
lappend LesTFAs $NouvTFA
}
regsub ".msf$" $NouveauFichierMSF "" NouveauFichierTFAs
append NouveauFichierTFAs ".tfas"
set NouveauFichierTFAs [SauveLesLignes $LesTFAs dans $NouveauFichierTFAs]
return [ConvertToMsf $NouveauFichierTFAs $NouveauFichierMSF]
}
proc AfficheLeNombreDeResidusDansLesDomaines {FichierMSF FichierBornes} {
foreach Ligne [LesLignesDuFichier $FichierBornes] {
scan $Ligne "%s %s" D F
set LesComptes [LeNombreDeResidusDansLeDomaine $FichierMSF $D $F]
EspionneL $LesComptes
foreach Compte $LesComptes {
scan $Compte "%s %d" Access nRes
if { ! [info exists DejaVu($Access)]} { lappend LesAccess $Access }
set DejaVu($Access) 1
lappend LesResultats($Access) $D $F $nRes
}
}
foreach Access $LesAccess {
set Ligne [format "%-10s" $Access]
foreach {D F nRes} [set LesResultats($Access)] {
append Ligne [format "%5s-%4s=%4s " $D $F $nRes]
}
lappend LesLignes $Ligne
}
return [AfficheVariable [join $LesLignes "\n"] "" "ResidueCountOf_$FichierMSF"]
}
proc LeNombreDeResidusDansLeDomaine {FichierMSF {D -1} {F end}} {
set TFAs [CreeLeTFAsDuMSF $FichierMSF]
set TmpTFAs [Sauve $TFAs dans [TmpFile]]
set Sortie {}
if { ! [regexp "end" $D]} { incr D -1}
if { ! [regexp "end" $F]} { incr F -1}
foreach Access [LaSequenceDuTFAs $TmpTFAs LaListeDesAccess] {
set Seq [QueLaSequenceDuTexteTFA [LaSequenceDuTFAs $TmpTFAs $Access]]
set Zone [string range $Seq $D $F]
regsub -all {\.|\-} $Zone "" ZoneSansPoint
set nRes [string length $ZoneSansPoint]
lappend Sortie [format "%-10s %5d %s---%s" $Access $nRes [string range $ZoneSansPoint 0 4] [string range $ZoneSansPoint end-4 end]]
}
# file delete -force $TmpTFAs
return $Sortie
}
proc DansAlignementPositionAbsolue {Pos Access {FichierMsf ""}} {
return [DansAlignementPositionAutreDe "Relative" $Pos $Access $FichierMsf]
}
proc DansAlignementPositionRelative {Pos Access {FichierMsf ""}} {
return [DansAlignementPositionAutreDe "Absolue" $Pos $Access $FichierMsf]
}
proc DansAlignementPositionAutreDe {RouA Pos Access {FichierMsf ""}} {
Wup "On a generalise ici le PositionAutreDe en memorisant pour tous les access du Msf"
global DAPAD
if {$FichierMsf=="" && [info exists DAPAD(FichierMsf)]} {
FaireLire "DansAlignementPositionAutreDe needs 4 params for its first call"
return -1
}
if {$FichierMsf!="" && [info exists DAPAD(FichierMsf)] && $FichierMsf!=$DAPAD(FichierMsf)} { unset DAPAD }
if {$FichierMsf!="" && ! [info exists DAPAD(FichierMsf)]} {
set DAPAD(FichierMsf) $FichierMsf
set n [DecortiqueUnMSF $FichierMsf LesNomsDesSequencesDansLOrdre Sequences]
if {$n<=0} { return -1 }
foreach NomDeSequence $LesNomsDesSequencesDansLOrdre {
set SeqGap [set Sequences($NomDeSequence)]
foreach {K V} [PositionAutreDe "GetArray" 0 $SeqGap] {
set DAPAD($K,$NomDeSequence) $V
}
}
}
if {[info exists DAPAD($RouA,$Pos,$Access)]} { return $DAPAD($RouA,$Pos,$Access) }
return -1
}
proc PositionAbsolueDansAlignement {Pos {SeqGap ""}} {
return [PositionAutreDe "Relative" $Pos $SeqGap]
}
proc PositionRelativeDansAlignement {Pos {SeqGap ""}} {
return [PositionAutreDe "Absolue" $Pos $SeqGap]
}
proc PositionAutreDe {RouA Pos {SeqGap ""}} {
global PositionAutreDe
Wup "positions start at 1"
Wup "PositionAutreDe Relative X Seq gives the abs (gapped) pos corresponding to rel (no gap) pos X"
Wup "the Absolute of a Relative is always defined"
Wup "the Relative of an Absolute is the previous existing one (0 if begin)"
Wup "RouA can be GetArray"
if {$SeqGap!=""} {
if {[info exists PositionAutreDe]} { unset PositionAutreDe }
regsub -all -nocase {[^A-Z]} $SeqGap "" Seq
set PosRelative 0
set PosAbsolue 0
foreach C [split $SeqGap ""] {
incr PosAbsolue
# if {[regexp -nocase {[A-Z]} $C]}
if {$C ne "." && $C ne "-"} {
incr PosRelative
set PositionAutreDe(Relative,$PosRelative) $PosAbsolue
}
set PositionAutreDe(Absolue,$PosAbsolue) $PosRelative
}
}
if {$RouA=="GetArray"} { return [array get PositionAutreDe] }
if {[info exists PositionAutreDe($RouA,$Pos)]} { return $PositionAutreDe($RouA,$Pos) }
return -1
}
proc EquivalentDansMSF {FichierMSF Pos Ref Autre} {
set G [PositionDansMSF Global $FichierMSF $Pos $Ref]
return [PositionDansMSF Local $FichierMSF $G $Autre]
}
proc PositionDansMSF {LoGlo FichierMSF Connu Access} {
global TmpTFAsDuMSFMemo NomDuFichierMSFMemo
if {[info exists TmpTFAsDuMSFMemo] && $NomDuFichierMSFMemo==$FichierMSF} {
set TmpTFAs $TmpTFAsDuMSFMemo
} else {
set TFAs [CreeLeTFAsDuMSF $FichierMSF]
set TmpTFAs [Sauve $TFAs dans [TmpFile]]
set TmpTFAsDuMSFMemo $TmpTFAs
set NomDuFichierMSFMemo $FichierMSF
}
set TFA [LaSequenceDuTFAs $TmpTFAs $Access]
set Seq [QueLaSequenceDuTexteTFA $TFA]
set L 0
set G 0
foreach C [split $Seq ""] {
if {$C!="-" && $C!="."} { incr L }
incr G
if {$LoGlo=="Local" && $G==$Connu} { return $L }
if {$LoGlo=="Global" && $L==$Connu} { return $G }
}
return -1
}
proc CreeLeMSFduTFAs {FichierOuTexteTFAs FichierMSF} {
return [ConvertToMsf $FichierOuTexteTFAs $FichierMSF]
}
proc CreeLeTFAsDuMSF {FichierMSF {AvecGap ""} {SansVide ""}} {
if {$AvecGap==""} { set AvecGap "AvecGap" }
if {$SansVide==""} { set SansVide 0 } else { set SansVide 1 }
set n [DecortiqueUnMSF $FichierMSF LesNomsDesSequencesDansLOrdre Sequences]
if {$n<=0} { return {} }
foreach NomDeSequence $LesNomsDesSequencesDansLOrdre {
set Seq [set Sequences($NomDeSequence)]
if {$AvecGap=="AvecGap"} {
regsub -all {\.} $Seq "-" Seq
} else {
regsub -all {[\.\-]} $Seq "" Seq
}
if {$SansVide && $Seq==""} { continue }
lappend LesTFAs [SequenceFormatTFA $Seq "$NomDeSequence" "protbrut"]
}
return [join $LesTFAs "\n"]
}
proc UneSequenceDuMSF {FichierMSF NomDeLaSequence {NoGap ""}} {
if {[DecortiqueUnMSF $FichierMSF LesNomsDesSequencesDansLOrdre Sequences]==0} { return "" }
if { ! [info exists Sequences($NomDeLaSequence)]} { return "" }
set Seq $Sequences($NomDeLaSequence)
if {[regexp -nocase "NoGap" $NoGap]} { regsub -all {[\.\-]} $Seq "" Seq }
return $Seq
}
proc TestDecortiqueUnMSF FichierMSF {
DecortiqueUnMSF $FichierMSF LesNoms Sequences
foreach NomSeq $LesNoms {
set Seq $Sequences($NomSeq)
regsub -all {\.} $Seq "" Lettres
Espionne "$NomSeq [string length $Seq] [string length $Lettres]"
Espionne $Seq
}
exit
}
proc LesAccessDuMSF TexteOuFichierMSF {
DecortiqueUnMSF $TexteOuFichierMSF LesAccess
return $LesAccess
}
proc DecortiqueUnMSF {TexteOuFichierMSF {aLesNomsDesSequencesDansLOrdre ""} {aSequences ""} {OutType ""}} {
#rR OutType peut etre ordali, msf, tfa, ou same. Dans ce cas on ne change pas la sequence
if {$aLesNomsDesSequencesDansLOrdre!="" } { upvar $aLesNomsDesSequencesDansLOrdre LesNomsDesSequencesDansLOrdre }
if {$aSequences!=""} { upvar $aSequences Sequences }
set LesNomsDesSequencesDansLOrdre {}
if {[regexp "\n" $TexteOuFichierMSF]} {
set LesLignes [split $TexteOuFichierMSF "\n"]
set FichierMSF "MSF"
} else {
set FichierMSF $TexteOuFichierMSF
if {[EstUnPAB $TexteOuFichierMSF]} { set FichierMSF [GscopeFile $FichierMSF "msf"] }
set LesLignes [LesLignesDuFichier $FichierMSF]
}
if {[llength $LesLignes] < 2} { return 0 }
set iSlashSlash [expr [lsearch -regexp $LesLignes "//"]+1]
#lm Traite le header du MSF pour recuperer la liste
#lm des noms de sequence
set iStart [lsearch -regexp $LesLignes {^MSF\:*\.\.}]
foreach Ligne [lrange $LesLignes $iStart+1 $iSlashSlash-2] {
set Ligne [string trim $Ligne]
if {$Ligne eq ""} { continue }
if {[string first "Name" $Ligne] == 0 && [string first "Weight" $Ligne] > 0} {
#lm ligne nom de sequence
regsub -all { +} $Ligne " " Ligne
set NomSeqLu [lindex [split $Ligne " "] 1]
regsub {/.*} $NomSeqLu "" NomSeqLu
set NomSeqLu [string map [list | :] $NomSeqLu]
set NomSeq $NomSeqLu
set NomSeq [BonAccess $NomSeq]
lappend LesNomsDesSequencesDansLOrdre $NomSeq
}
}
#lm Traite le corps du MSF
foreach Ligne [lrange $LesLignes $iSlashSlash end] {
if { ! [regexp {[\.a-zA-Z]} $Ligne] } { continue }
scan $Ligne "%s" NomSeqLu
set iNomSeqLu [string first $NomSeqLu $Ligne]
set NomSeqLu [string map [list | :] $NomSeqLu]
set iBlanc [expr {$iNomSeqLu+[string length $NomSeqLu]}]
regsub {/.*} $NomSeqLu "" NomSeqLu
set NomSeq $NomSeqLu
set NomSeq [BonAccess $NomSeq]
set BoutSequence [string map [list " " ""] [string range $Ligne $iBlanc end]]
set BoutSequence [BonneSequencePourAlignement $BoutSequence $OutType]
if { ! [info exists DejaVu($NomSeq)]} {
#lm on tient compte des doublons
#lappend LesNomsDesSequencesDansLOrdre $NomSeq
}
if {$aSequences!=""} {
if { ! [info exists DejaVu($NomSeq)]} {
set Sequences($NomSeq) $BoutSequence
} else {
append Sequences($NomSeq) $BoutSequence
}
}
set DejaVu($NomSeq) 1
}
return [llength $LesNomsDesSequencesDansLOrdre]
#rR le reste est obsolete
# if {$aSequences!=""} {
# set Lns [array get Sequences]
# Log $Lns
# unset LesNomsDesSequencesDansLOrdre
# if {[info exists Sequences]} { unset Sequences }
# foreach {n s} $Lns {
# set n [BonAccess $n]
# set s [BonneSequence $s]
# set Sequences($n) $s
# }
# set LesNomsDesSequencesDansLOrdre [array names Sequences]
# }
# return [llength $LesNomsDesSequencesDansLOrdre]
}
proc CorrectionPourVarsplicDuBlastPPourTous {} {
foreach Nom [ListeDesPABs] {
set Fichier "[RepertoireDuGenome]/blastp/$Nom"
if { ! [file exists $Fichier]} { continue }
regsub "/blastp/" $Fichier "/blastpOK/" Out
Espionne [CorrectionPourVarsplicDuBlastP $Fichier $Out]
}
exit
}
proc CorrectionPourVarsplicDuBlastP {Fichier {Out ""}} {
if {$Out==""} { set Out $Fichier }
set nVus 0
set LeNouveau {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp -nocase {^VARSPLIC\:} $Ligne]} {
incr nVus
scan $Ligne "%s %s" BId Access
set BonAccess [StringApres ":" dans $BId]
if { ! [string equal -nocase $Access $BonAccess]} {
set d [expr [string length $BonAccess] - [string length $Access]]
if {$d<0} {
regsub " $Access" $Ligne " $BonAccess[string repeat " " [expr -$d]]"
}
if {$d==0} {
regsub " $Access" $Ligne " $BonAccess"
}
if {$d>0} {
regsub " $Access" $Ligne " $BonAccess" Ligne
set Ligne [string replace $Ligne [expr 66-$d+1] 66]
}
lappend LeNouveau $Ligne
continue
}
}
if {[regexp -nocase {>VARSPLIC\:} $Ligne]} {
if {$nVus==0} { break }
scan $Ligne "%s %s" BId Access
set BonAccess [StringApres ":" dans $BId]
regsub " $Access" $Ligne " $BonAccess" Ligne
lappend LeNouveau $Ligne
continue
}
lappend LeNouveau $Ligne
continue
}
if {$nVus==0 && $Fichier==$Out} { return $Out }
if {$nVus==0 && $Fichier!=$Out} { file copy -force $Fichier $Out ; return $Out }
return [SauveLesLignes $LeNouveau dans $Out]
}
proc MsfLeon {Nom {Quoi ""}} {
if {$Quoi==""} { set Quoi "Text" }
set FichierLeon "[RepertoireDuGenome]/msfleon/$Nom"
if {$Quoi=="FileName"} { return $Fichier }
if { ! [file exists $FichierLeon]} { return "" }
if {$Quoi=="Text"} { return [ContenuDuFichier $FichierLeon] }
if {$Quoi=="Lines"} { return [LesLignesDuFichier $FichierLeon] }
if {$Quoi=="NorMD"} {
}
}
proc FromDbClustalToLeon Nom {
set FichierDbClustal "[RepertoireDuGenome]/msfdbclustal/$Nom"
set FichierRascal "[RepertoireDuGenome]/msfrascal/$Nom"
set FichierLeon "[RepertoireDuGenome]/msfleon/$Nom"
if {[]} {}
}
proc ConvertToOneHundredPourTous {{RepIn ""} {RepOut ""}} {
if {$RepIn==""} {
set RepIn "[RepertoireDuGenome]/msf"
}
if {$RepOut==""} {
set RepOut "$RepIn.100"
if { ! [file exists $RepOut]} { file mkdir $RepOut }
}
foreach Nom [ListeDesPABs] {
set In "$RepIn/$Nom"
set Out "$RepOut/$Nom"
Espionne "ConvertToOneHundred $In $Out"
if { ! [file exists $In]} { continue }
ConvertToOneHundred $In $Out
}
}
proc ConvertToOneHundred {In Out} {
if {[regexp "NoSequencesToAlign" [PremiereLigneDuFichier $In]]} {
File copy -force $In $Out
return $Out
}
set Tmp [TmpFile]
set LeDebut {}
set YADebut 0
foreach Ligne [LesPremieresLignesDuFichier $In 10] {
if {[regexp -nocase {Name *\: } $Ligne]} { break }
set YADebut 1
lappend LeDebut $Ligne
}
if {[catch {exec clustalw $In -convert -output=gscope -outfile=$Tmp} Message]} {
Warne "Clustalw couldn't convert the msf to 100 : \n$Message"
File copy -force $In $Out
return $Out
}
set LeNouveau $LeDebut
set OnAttendName 1
foreach Ligne [LesLignesDuFichier $Tmp] {
if {$YADebut && $OnAttendName && ! [regexp -nocase {Name *\: } $Ligne]} { continue }
set OnAttendName 0
lappend LeNouveau $Ligne
}
file delete -force $Tmp
return [SauveLesLignes $LeNouveau dans $Out]
}
proc RascalPourTous {{NomATraiter ""}} {
global RepertoireDuGenome
set AvecPasTouche 1
if {$NomATraiter == ""} {
set Liste [ListeDesPABs]
} elseif {[llength $NomATraiter]==1} {
if {[EstUnPAB $NomATraiter]} { set AvecPasTouche 0 }
set Liste [list $NomATraiter]
} else {
set Liste $NomATraiter
}
set Repertoire "$RepertoireDuGenome/msfrascal"
if { ! [file exists "$Repertoire"]} {
File mkdir $Repertoire
}
set GardeTout 1
set TestExistence 1
while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
set TestExistence 1
set GardeTout 1
break
} elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
set TestExistence 0
set GardeTout 0
break
} elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
set TestExistence 1
set GardeTout 0
break
}
}
set LesCrees {}
foreach Nom $Liste {
if {$AvecPasTouche && [PasTouche $Nom]} { continue }
set FichierMSF "$RepertoireDuGenome/msf/$Nom"
set FichierRascal "$Repertoire/$Nom"
if { ! [file exists $FichierMSF]} {
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
if {$GardeTout && [file exists $FichierRascal] } {
Espionne "$Nom already done"
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
if { $TestExistence && [file exists $FichierRascal] } {
if {[OuiOuNon "$FichierRascal already exists\nDo I keep it ?"]} {
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
}
set FichierCree [Rascal $FichierMSF $FichierRascal "Annotate" ]
lappend LesCrees $FichierCree
Espionne "Rascal created $FichierCree"
if {$AvecPasTouche} { FinPasTouche $Nom }
}
return $LesCrees
}
proc Rascal {FichierOuNom {Destin ""} {Annotate "Annotate"}} {
global RepertoireDuGenome
set Annotate [string equal -nocase $Annotate "Annotate"]
set Nom [file tail $FichierOuNom]
if { ! [regexp "/" $FichierOuNom]} { set FichierOuNom "$RepertoireDuGenome/msf/$Nom" }
set FichierMSF $FichierOuNom
if { ! [file exists $FichierOuNom]} { return "" }
if {[regexp "NoSequence" [PremiereLigneDuFichier $FichierOuNom]]} { return "NoSequencesToAlign" }
if {$Annotate} {
set OldNorMD [MDScore $FichierMSF "CalculeMoi"]
}
if {[string equal -nocase $Destin "InRascalDir"]} {
set RascalDir "$RepertoireDuGenome/msfrascal"
if { ! [file exists $RascalDir]} { File mkdir $RascalDir }
set FichierRascal "$RascalDir/$Nom"
} elseif { $Destin=="" } {
set FichierRascal $FichierMSF
} else {
set FichierRascal $Destin
}
set TmpRascal "[TmpFile].rascal"
if {[catch {exec rascal $FichierMSF $TmpRascal} Message]} {
Warne "Error from rascal. Message follows \n$Message"
return ""
}
if { ! [file exists $TmpRascal]} {
Warne "Error from rascal. File not created"
return ""
}
global RascalConvertToOneHundred
if { ! [info exists RascalConvertToOneHundred]} { set RascalConvertToOneHundred 1 }
if {$RascalConvertToOneHundred} { ConvertToOneHundred $TmpRascal $TmpRascal }
if {$Annotate} {
set NewNorMD [MDScore $TmpRascal "CalculeMoi"]
set LeRascal [LesLignesDuFichier $TmpRascal]
set DeuxiemeLigne [string trimright [IemeLigneDuFichier $FichierMSF 2]]
if {$OldNorMD<=$NewNorMD} {
set Changed "improved"
} else {
set Changed "reduced"
}
append DeuxiemeLigne " Rascal $Changed NorMD from $OldNorMD to $NewNorMD"
set LeRascal [linsert $LeRascal 1 $DeuxiemeLigne]
}
File delete -force $TmpRascal
return [SauveLesLignes $LeRascal dans $FichierRascal]
}
proc Tdbc {} {
global RepertoireDuGenome
set LesAccess [LesLignesDuFichier "$RepertoireDuGenome/descriptifs/VCHO10004"]
set Texte [join $LesAccess "\n"]
DbClustal toto oscar.msf $Texte "AvecSelection"
exit
}
proc TestGscopeCroises {} {
EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP {} Court"]
EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY1969 BlastP {} Court"]
EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353333 BlastP {} Court"]
EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2354 BlastP"]
EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP"]
EspionneL [QuestionDeScience Pabyssi "ret LesOrganismesOrthologues PABY2353 BlastP"]
}
proc LesAccessDuAliInOut {NomOuFichier {InOut "All"}} {
global RepertoireDuGenome
set Nom [file tail $NomOuFichier]
set Fichier "$RepertoireDuGenome/aliinout/$Nom"
if { ! [file exists Fichier]} { set Fichier $NomOuFichier }
if { ! [file exists Fichier]} { return {} }
set All [regexp -nocase "All" $InOut]
set In [regexp -nocase "In" $InOut]
set Out [regexp -nocase "Out" $InOut]
set LesAccess {}
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s %s" BID Access
if {[EstUnAccessPDB $BID]} { set Access $BID }
if {$All} { lappend LesAccess $Access }
if {$In && [regexp "accepted" $Ligne]} { lappend LesAccess $Access }
if {$Out && [regexp "rejected" $Ligne]} { lappend LesAccess $Access }
}
return $LesAccess
}
proc RapportAliInOut {Rapport Nom} {
global SortieRapportAliInOut
global SortieRapportAliInOutFichierMemo
if { ! [info exists SortieRapportAliInOut]} {
set Texte "$Nom $Rapport"
Espionne $Texte
return $Texte
}
set FichierSortie "$SortieRapportAliInOut/$Nom"
if { ! [info exists SortieRapportAliInOutFichierMemo] \
|| $FichierSortie!=$SortieRapportAliInOutFichierMemo} {
if {[file exists $FichierSortie]} { File delete -force $FichierSortie }
}
set SortieRapportAliInOutFichierMemo $FichierSortie
return [AppendAuFichier $FichierSortie $Rapport]
}
proc RacineDuPDB Access {
regsub {_[A-Z]+$} $Access "" Racine
return $Racine
}
proc EstUnFragment {BID {Access ""} {DE ""}} {
if {$DE!=""} { return [regexp -nocase "FRAGMENT" $DE] }
return 0
}
proc TailleDuDescriptifDuBlastP {{Ask ""}} {
global RepertoireDuGenome
global GscopeDir
global TailleDuDescriptifDuBlastP
set Ask [regexp -nocase "^Ask$" $Ask]
if {! $Ask && [info exists TailleDuDescriptifDuBlastP]} {
return $TailleDuDescriptifDuBlastP
}
set FichierTaille "$RepertoireDuGenome/fiches/sizedescriptif"
if { $Ask || ! [file exists $FichierTaille]} {
set FichierTailleDefaut "$GscopeDir/gscope_sizedescriptif"
if {[file exists $FichierTailleDefaut] && \
[OuiOuNon "Do I copy the file \n\
$FichierTailleDefaut\n\
to $FichierTaille\n ?"]} {
File copy $FichierTailleDefaut $FichierSortie
} else {
while {[OuiOuNon "Do You want to load an existing file with sizes for description ?"]} {
set F [ButineArborescence "All" $RepertoireDuGenome]
if {$F==""} { continue }
if {[OuiOuNon "Do I copy it to $FichierTaille ?"]} {
File copy -force $F $FichierTaille
} else {
set FichierTaille $F
}
break
}
}
}
if {[file exists $FichierTaille]} {
set VT [ContenuDuFichier $FichierTaille]
} else {
set VT "90 120 30 10. respectively : at_least max_with_complete_genomes max_pdb expect"
set Ask 1
}
while {$Ask && [OuiOuNon "Do You want to modify the sizes ?"]} {
set NewVT [Entre $VT]
if {$NewVT==""} { continue }
set VT $NewVT
if {[OuiOuNon "Do I save these values in $FichierTaille ?"]} {
Sauve $VT dans $FichierTaille
}
}
set TailleDuDescriptifDuBlastP $VT
return $VT
}
proc LesDescriptifsDuBlast {FichierOuNom {Source ""}} {
#rR Petite remarque : LesDescriptifs c'est assez compliqué
#rR ça a l'air de tourner en rond ... car ici on crée les descritptifs même s'ils existent déjà
#rR en fait il ne le rajoute que s'il n'existe pas
#rR (StockeLeDescriptif est assez intelligent )
global RepertoireDuGenome
global SeuilExpectPourJulie
if {$Source==""} { set Source "blastp" }
set Nom [file tail $FichierOuNom]
scan [TailleDuDescriptifDuBlastP] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect
set MaxADecortiquer [expr $MaxVoulus+$MaxPDB]
if {[info exists SeuilExpectPourJulie]} {
set SeuilExpect $SeuilExpectPourJulie
}
Wup "On ne veut plus voir le meme PAB .......... peut servir autrement ... "
set LesIndesirables {}
if {0 && [regsub "^ABY$" $Nom "PAB" Indesirable]} {
lappend LesIndesirables $Indesirables
}
set LesCandidats {}
if {$Source=="daedalus" || ($Source=="" &&\
[OuiOuNonMemo "Do I use Daedalushits to collect the candidates for DbClustal ?" 0])} {
set Source "daedalushits"
set Fichier "$RepertoireDuGenome/$Source/$Nom"
while { ! [file exists $Fichier]} {
if {[OuiOuNon "May be you forgot to run DaedalusHitsDuBlastPPourTous.\n\
Do I run it now ... (it could take a while) ? "]} {
DaedalusHitsDuBlastPPourTous "EnProcessExterne"
} else {
if {[OuiOuNon "Do I return an empty list of orthologs for $Nom ?" 0]} { return {} }
if {[OuiOuNon "Do I use the blastp file ?"]} {
return [LesDescriptifsDuBlast $FichierOuNom "blastp"]
}
}
}
set Texte [ContenuDuFichier $Fichier]
set PN 0.0009876
while 1 {
set BlastHit [ValeurDeLaBalise "BlastHit" Texte "Rogner" BH]
if {$BlastHit==""} { break }
set BanqueId $BH
set Access $BH
set AccessOK $BH
set OldPN $PN
set ID [ValeurDeLaBalise "ID" BlastHit "NePasRogner"]
set AC [ValeurDeLaBalise "AC" BlastHit "NePasRogner"]
set PN [ValeurDeLaBalise "PN" BlastHit "NePasRogner"]
if {$PN=="0.000999"} { set PN $OldPN }
set OX [ValeurDeLaBalise "OX" BlastHit "NePasRogner"]
set GN [ValeurDeLaBalise "GN" BlastHit "NePasRogner"]
set DE [ValeurDeLaBalise "DE" BlastHit "NePasRogner"]
set OS [ValeurDeLaBalise "OS" BlastHit "NePasRogner"]
set OC [ValeurDeLaBalise "OC" BlastHit "NePasRogner"]
set CandId [lindex [split $ID " "] 0]
set CandAc [lindex [split $AC " "] 0]
if {$CandId==""} { set CandId $BanqueId }
if {$CandAc==""} { set CandAc $Access }
if {$OS=="" && $OX!=""} { set OS [Tax $OX "Name"] }
regsub -all " " $DE "_" BeauDE
set Candidat "$CandId $CandAc $PN $OS $BeauDE $OC"
lappend LesCandidats $Candidat
regsub -all {\:} $DE "_" DE
set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX"
StockeLeDescriptif $AccessOK $Descriptif $Nom
}
Espionne "$Nom accepts [llength $LesCandidats] candidats"
return $LesCandidats
}
if {[file exists $FichierOuNom] && $Nom!=$FichierOuNom} {
set Fichier $FichierOuNom
} else {
set Fichier "$RepertoireDuGenome/$Source/$Nom"
}
if { ! [file exists $Fichier]} { return {} }
DecortiqueBlast $Fichier $SeuilExpect $MaxADecortiquer Query lBanqueId lAccess lDE lProfil lPN
#rR rajout 2014/11/25
set LesBonBid {}
set LesBonAcc {}
foreach BID $lBanqueId ACC $lAccess {
if {[regexp {\|} $BID]} {
lassign [split $BID "|"] Ban BonAcc BonBid
lappend LesBonAcc $BonAcc
lappend LesBonBid $BonBid
continue
}
lappend LesBonAcc $ACC
lappend LesBonBid $BID
}
set lAccess $LesBonAcc
set lBanqueId $LesBonBid
set NbEnMemoire [PrepareLesSequencesDesBanques $lBanqueId $lAccess "DefaultBlastPDatabase"] ;#rR 20171031 rajout de DefaultBlastPDatabase
Espionne "$NbEnMemoire/[llength $lBanqueId] EMBL mis en memoire par PrepareLesSequencesDesBanques"
foreach BanqueId $lBanqueId Access $lAccess PetitDE $lDE Profil $lProfil PN $lPN {
if {[lsearch -exact $LesIndesirables $Access] > 0 } { continue }
# if {$FromDescriptifs} {
# }
set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
if {$LesLignesEMBL=={}} { continue }
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
Espionne $DE
if {$DE==""} { set DE $PetitDE }
LeDescriptif $AC $Nom $DE ;#rR rajout 2013/10/17 : Mise en memoire pour ConcatLeTFAs
regsub -all " " $DE "_" BeauDE
lappend LesCandidats "$BanqueId $Access $PN $OS $BeauDE $OC"
regsub -all {\:} $DE "_" DE
set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX"
StockeLeDescriptif $AccessOK $Descriptif $Nom
}
return $LesCandidats
}
proc TestCreeLaListeLesCopains {} {
}
proc CreeLaListeLesCopains {FichierOuNom {Source ""} {EvalCommand ""}} {
global RepertoireDuGenome
global NotreOS
global DejaVuCeComplet
global SeuilExpectPourJulie
global LesOrganismesModelesAAligner
global WithoutVarsplic
global WithoutFragment
global FirstPDBOnly
if { ! [info exists WithoutVarsplic]} { set WithoutVarsplic 0 }
if { ! [info exists WithoutFragment]} { set WithoutFragment 1 }
if { ! [info exists FirstPDBOnly] } { set FirstPDBOnly 1 }
if {[OnTraiteMS2PH]} {
set WithoutFragment 0
global TryGCG ; set TryGCG 0
}
if {$Source==""} { set Source "blast" }
Wup "Creates the list of best orthologs in blastp or ballast"
set Nom [file tail $FichierOuNom]
set LesOrganismesFamiliers [FamiliarOrganism "LaListeMerci"]
set LesOrganismesImportants [LesOrganismesImportantsPourDBClustal]
scan [TailleSortiePourDBClustal] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect
if { ! [info exists DejaVuCeComplet]} {
foreach Ligne $LesOrganismesImportants {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
set Genre ""
set Espece ""
scan $Ligne "%s %s" Genre Espece
set Complet "$Genre $Espece"
set Orga [Glossaire $Complet Complet]
set DejaVuCeComplet([string toupper $Orga]) 0
}
}
foreach Genome [array names DejaVuCeComplet] {
set DejaVuCeComplet($Genome) 0
}
set nPDB 0
set nCops 0
set ncomplets 0
set LesCopains {}
set LesCandidatsPotentiels [LesDescriptifsDuBlast $FichierOuNom $Source]
foreach Candidat $LesCandidatsPotentiels {
if { $nCops >= $MaxVoulus} {
RapportAliInOut "$BanqueId $Access break : ncops $nCops >= $MaxVoulus" $Nom
break
}
set Genre "Unknown unknown"
set Espece ""
set DE ""
scan $Candidat "%s %s %f %s %s %s" BanqueId Access PN Genre Espece DE
regsub -all "_" $DE " " DE
if {$EvalCommand!=""} {
set R [EvalCom $EvalCommand $Candidat]
if {[regexp -nocase "^Reject" $R]} {
RapportAliInOut "$BanqueId $Access rejected by evalcom : $R" $Nom
continue
}
}
if { $Source != "ballast" && $PN > $SeuilExpect } {
RapportAliInOut "$BanqueId $Access break : expect $PN > $SeuilExpect" $Nom
break
}
if {$WithoutVarsplic && [regexp -nocase "^VARSPLIC" $BanqueId]} {
RapportAliInOut "$BanqueId $Access rejected, VARSPLIC : $DE" $Nom
continue
}
if {$WithoutFragment && [EstUnFragment $BanqueId $Access $DE]} {
RapportAliInOut "$BanqueId $Access rejected, fragment : $DE" $Nom
continue
}
if {[EstUnAccessPDB $BanqueId]} {
set Racine [RacineDuPDB $BanqueId]
if {$FirstPDBOnly} {
if {[info exists DejaVuCePDB($Racine)]} {
RapportAliInOut "$BanqueId $Access rejected, other PDB already taken [set DejaVuCePDB($Racine)]." $Nom
continue
}
set DejaVuCePDB($Racine) $BanqueId
}
if {[incr nPDB]>$MaxPDB} {
RapportAliInOut "$BanqueId $Access rejected, more than $MaxPDB PDB." $Nom
continue
}
set Orga [OrganismeDuPDB $BanqueId]
lappend LesCopains "$BanqueId $Access $PN $Orga"
RapportAliInOut "$BanqueId $Access $Orga accepted after $nCops th, PDB $nPDB" $Nom
continue
}
set OS "$Genre $Espece"
set Orga [OrganismeCanonique $OS "NonStricte"]
if {$Orga==""} {
if {[OuiOuNon "I skip $OS"]} {
RapportAliInOut "$BanqueId $Access rejected : $Organisme unknown >$OS<" $Nom
continue
}
set Orga $OS
}
Wup "Si on ne veut qu'une seule fois chaque complet mettre 1"
set UneSeuleFoisLesComplets [OuiOuNonMemo "Do I use only one time each organism" 0]
if {$UneSeuleFoisLesComplets && [info exists DejaVuCeComplet([string toupper $Orga])]} {
if { $nCops >= $MinObliges && [set DejaVuCeComplet([string toupper $Orga])]} {
RapportAliInOut "$BanqueId $Access rejected : $Orga already seen." $Nom
continue
}
} else {
if { $nCops >= $MinObliges && \
! [info exists DejaVuCeComplet([string toupper $Orga])] } {
RapportAliInOut "$BanqueId $Access rejected : $Orga $nCops >= $MinObliges" $Nom
continue
}
}
if {[info exists DejaVuCeComplet([string toupper $Orga])]} {
set DejaVuCeComplet([string toupper $Orga]) 1
}
incr nCops
RapportAliInOut "$BanqueId $Access $Orga accepted as $nCops th." $Nom
lappend LesCopains "$BanqueId $Access $PN $Orga"
}
return $LesCopains
}
proc TFAsDuBlast {Fichier {Organisme ""} {SeuilExpect ""} {MaxSeq ""} {WithBId ""} {AlreadyTFA ""}} {
if {$SeuilExpect==""} { set SeuilExpect 0.001 }
if {$MaxSeq==""} { set MaxSeq "SansLimiteDeNombre" }
set WithBId [string equal -nocase $WithBId "WithBId"]
set AlreadyTFA [string equal -nocase $AlreadyTFA "AlreadyTFA"]
if {$Organisme!=""} { set Organisme [Glossaire $Organisme Complet] }
DecortiqueBlast $Fichier \
$SeuilExpect $MaxSeq Query lBanqueId lAccess lDE lProfil lPN
PrepareLesSequencesDesBanques $lBanqueId $lAccess
set OnVeutQuoi "OnVeutEMBL"
if {$AlreadyTFA} { set OnVeutQuoi "OnVeutNature" }
set LesTFAs {}
foreach BanqueId $lBanqueId Access $lAccess Profil $lProfil PN $lPN {
set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK $OnVeutQuoi]
if { ! $AlreadyTFA} {
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
if {$Organisme!="" && $OS!=$Organisme} { continue }
regsub -all {\:} $DE "_" DE
set Format "embl"
if {[regexp -nocase {^REFSEQ:} $BanqueId]} { set Format "tfa" }
set BouA $AC
if {$WithBId} { set BouA $BanqueId }
set TFA [SequenceFormatTFA_l $LesLignesEMBL "$BouA $OS $DE" $Format]
} else {
set TFA [join $LesLignesEMBL "\n"]
}
lappend LesTFAs $TFA
# lappend LesCandidats "$BanqueId $Access $PN $OS $OC"
}
return [join $LesTFAs "\n"]
# return $LesCandidats
}
proc OnAligneTousLesElusDuBlastPPar {Methode {Value ""}} {
#rR Attention toutes les méthodes sont exclusives ... on ne peut en faire qu'une seule
global OnAligneTousLesElusDuBlastPPar
if {$Value!=""} {
if {[info exists OnAligneTousLesElusDuBlastPPar]} { unset OnAligneTousLesElusDuBlastPPar }
set OnAligneTousLesElusDuBlastPPar($Methode) $Value
}
if {[info exists OnAligneTousLesElusDuBlastPPar($Methode)]} { return $OnAligneTousLesElusDuBlastPPar($Methode) }
return 0
}
proc DbClustalPourTous {{NomATraiter ""} {Source ""} {ChangeQuery ""}} {
global RepertoireDuGenome
global LesOrganismesModelesAAligner
global OptionsBallastPourJulie SeuilExpectPourJulie
global OptionsBallastPourJulieDemande
global SortieRapportAliInOut
global NotreOS
global OnEffaceBallast
global OkPourTfaDesCopains ;#rR 2015/01/19 mis en debut et lu aussi dans source
if {[string equal -nocase "All" $NomATraiter]} { set NomATraiter "" } ;#rR pour eviter le "" en ligne de commande
set QueryForAnchors ""
set SourceOrigine $Source
set ForceTFAsDesCopains 0
if {[regexp -nocase "TFAsDesCopains" $Source]} {
set OkPourTfaDesCopains 1
set ForceTFAsDesCopains 1
}
if {[string equal -nocase $NomATraiter "All"]} { set NomATraiter "" }
if {[OnTraite "Ribosome"]} {
UseBanqueIdForDbClustal 1
set SeuilExpectPourJulie 10.
}
if {[regexp -nocase "Bandelettes" $Source]} {
OnAligneTousLesElusDuBlastPPar "Bandelettes" 1
set OptionsBallastPourJulie "-dbclustal 0.000000"
set SeuilExpectPourJulie 10.
if {[OnTraiteMS2PH]} { set SeuilExpectPourJulie 0.001 }
set OptionsBallastPourJulieDemande 1
OnVireLesMonstresLointains 1
}
if {[regexp -nocase "Mounir" $Source]} {
OnAligneTousLesElusDuBlastPPar "Mounir" 1
set OptionsBallastPourJulie "-dbclustal 0.000000"
set SeuilExpectPourJulie 0.001
set OptionsBallastPourJulieDemande 1
OnVireLesMonstresLointains 1
}
if {[regexp -nocase "AuChoix" $Source]} {
OnAligneTousLesElusDuBlastPPar "AuChoix" 1
set OptionsBallastPourJulie "-dbclustal 0.000000"
set SeuilExpectPourJulie 0.001
set OptionsBallastPourJulieDemande 1
OnVireLesMonstresLointains 1
}
#rR 2014/07/01 rajout de OrthologsFromOrthoInspector
#rR ne marche que pour CilioCarta pour le moment ... voir ci-dessous Source
#rR Et EvalCommand ... ne marche pas encore .............. à développer :
#rR En fait j'imagine une commande qui rejette chaque access du blast
#rR Le tout est de savoir où le placer ... avant, pendant ou après LaSelectionUnique
set EvalCommand 0
if {[regexp "^eval_" $Source]} {
set EvalCommand 1
regsub "^eval_" $Source "" Commande
regsub -all "_" $Commande " "
}
set OnEffaceBallast 0
set AvecPasTouche 1
set Liste {}
if {$NomATraiter == "" } {
set Liste [ListeDesPABs]
} elseif {$NomATraiter=="ListeDesFusions"} {
set Liste [ListeDesFusions]
} elseif {[EstUnPAB $NomATraiter]} {
set Liste [list $NomATraiter]
set AvecPasTouche 0
} elseif {[llength $NomATraiter] > 1} {
set Liste $NomATraiter
} elseif {[file exists $NomATraiter]} {
set Liste [LesLignesDuFichier $NomATraiter]
} elseif {$NomATraiter=="PourJulie"} {
set Liste [LesLignesDuFichier "[RepertoireDuGenome]/fiches/liste_pour_julie"]
}
if { ! [info exists SortieRapportAliInOut]} {
set SortieRapportAliInOut "$RepertoireDuGenome/aliinout"
if { ! [file exists $SortieRapportAliInOut]} {
File mkdir $SortieRapportAliInOut
}
}
if {[OnTraite "PubSpine"]} {
set OptionsBallastPourJulieDemande 1
set OptionsBallastPourJulie "-dbclustal 0.00000"
set SeuilExpectPourJulie 10
}
if { ! [info exists OptionsBallastPourJulieDemande] \
&& [OuiOuNon "Do You want to change ballast options and expect ?" 0]} {
# set OptionsBallastPourJulie [Entre "-dbclustal 0.000001"]
set OptionsBallastPourJulie [Entre "-dbclustal 0.000000"]
set SeuilExpectPourJulie [Entre 10.]
}
set OptionsBallastPourJulieDemande 1
set RepertoireMSF "$RepertoireDuGenome/msf"
if { ! [file exists $RepertoireMSF]} { File mkdir $RepertoireMSF }
set RepertoireTfasDesCopains "$RepertoireDuGenome/tfasdescopains"
if { ! [file exists $RepertoireTfasDesCopains]} { File mkdir $RepertoireTfasDesCopains }
if {$NomATraiter==""} {
set LesQuels "*"
} else {
set LesQuels [file tail $NomATraiter]
}
set Conserve 0
if {[llength [glob -nocomplain "$RepertoireMSF/$LesQuels"]] > 0} {
set Conserve [OuiOuNon "Should I keep the existing files in $RepertoireMSF"]
}
set UseBirdFromTheBlast 0
set Status "NothingHappend"
foreach Nom $Liste {
if {[Fantome $Nom]} { continue }
set FichierMSF "$RepertoireMSF/$Nom"
if {$Conserve && [file exists $FichierMSF] } { continue }
if {$AvecPasTouche && [PasTouche $Nom]} { continue }
Espionne "Je vais preparer $Nom pour DbClustal"
set FichInTFAs "$RepertoireTfasDesCopains/$Nom"
if { ! [info exists OkPourTfaDesCopains]} {
set OkPourTfaDesCopains [OuiOuNon "Can I use the existing files $FichInTFAs" 0]
}
if {$ForceTFAsDesCopains && ! [file exists $FichInTFAs]} {
Sauve "NoSequencesToAlign" dans $FichierMSF
Warne "$Nom fichier tfasdescopains is empty !!!!"
FinPasTouche $Nom
continue
} elseif {$OkPourTfaDesCopains && [file exists $FichInTFAs]} {
set Source $FichInTFAs
set AvecQuoi "AvecFichierTFAs"
if {[regexp -nocase "First" $ChangeQuery]} {
Espionne $FichInTFAs [PremiereLigneDuFichier $FichInTFAs]
regexp {^>([^ ]+) *$} [PremiereLigneDuFichier $FichInTFAs] Match QueryForAnchors
Espionne QueryForAnchors $QueryForAnchors
}
} else {
set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"
Espionne $FichierBlastP
BirdFromTheBlast $FichierBlastP
if { ! [file exists $FichierBlastP]} {
Warne "$Nom pas de fichier blastp"
FinPasTouche $Nom
continue
}
if {[OnAligneTousLesElusDuBlastPPar "Tous"]} {
#rR il me semble qu'on ne passe jamais par là !!!!!!!!!!!!!!!
set lBanqueId {}
set lAccess {}
set lPN {}
DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" Query \
lBanqueId lAccess lDE lProfil lPN
set O ""
set LaSelectionUnique {}
foreach B $lBanqueId A $lAccess E $lPN {
#rR rajouté 2014/11/25 ************************************************************
if {[regexp "\|" $B]} {
set A [lindex [split $B "|"] 1]
set B [lindex [split $B "|"] 2]
}
lappend LaSelectionUnique "$B $A $E $O"
}
} elseif { [OnAligneTousLesElusDuBlastPPar "Bandelettes"] } {
set LaSelectionUnique [LesElusDuBlastPParBandelettes $Nom "blastp"]
} elseif { [OnAligneTousLesElusDuBlastPPar "Mounir"]} {
set LaSelectionUnique [LesElusDuBlastPParMounir $Nom "blastp"]
} elseif { [OnAligneTousLesElusDuBlastPPar "AuChoix"] } {
set LaSelectionUnique [LesElusDuBlastPParAuChoix $Nom "blastp"]
} elseif {[regexp -nocase "Ortholog" $SourceOrigine]} {
set LaSelectionUnique [OiOrthologsFromCilioCarta $Nom "IDs"]
} else {
set LaSelectionUnique [CreeLaListeLesCopains $FichierBlastP "blastp"]
}
# BirdFromTheBlast "Reset"
if {[llength $LaSelectionUnique] == 0} {
Warne "$Nom pas de sequences a aligner"
Sauve "NoSequencesToAlign" dans $FichierMSF
FinPasTouche $Nom
continue
}
set FichierQuery "$RepertoireDuGenome/prottfa/$Nom"
if { ! [file exists $FichierQuery]} {
set FichierQuery "$RepertoireDuGenome/protembl/$Nom"
}
if { ! [file exists $FichierQuery]} {
Warne "$Nom pas de fichier prottfa ni protembl"
FinPasTouche $Nom
continue
}
set Selection "$FichierQuery $Nom 0.0 $NotreOS\n"
append Selection [join $LaSelectionUnique "\n"]
set Source $Selection
set AvecQuoi "AvecSelection"
}
Espionne $Source
set Status [DbClustal $Nom $FichierMSF $Source $AvecQuoi "" "" "" $QueryForAnchors]
if {[regexp "^NoSeq" $Status] || [regexp "PasDeSeq" $Status]} {
Sauve "NoSequencesToAlign" dans $FichierMSF
}
if {$Status=="OK"} {
if {$OnEffaceBallast} {
set FichierBallast "$RepertoireDuGenome/ballast/$Nom"
if {[file exists $FichierBallast]} { File delete -force $FichierBallast }
foreach FichierBallastExt [glob -nocomplain "$FichierBallast.*"] {
File delete -force $FichierBallastExt
}
}
}
FinPasTouche $Nom
}
return $Status
}
proc DbClustal {Nom FichierMSF {Source ""} {AvecQuoi ""} {KeepInTFAs ""} {KeepAnchors ""} {KeepLog ""} {Query ""}} {
global RepertoireDuGenome
global Commandes
global RepertoireDeTravail
global MyDbClustal
JeMeSignale
Wup "AvecQuoi tells what is source. It can be AvecSelection AvecFichierTFAs AvecTexteTFAs"
Wup "Each Keep... can be a file name or 'Keep' so it will not be deleted"
if { ! [regexp "^/" $FichierMSF]} { set FichierMSF "[pwd]/$FichierMSF" }
if {$AvecQuoi==""} { set AvecQuoi "AvecSelection" }
if {$KeepInTFAs==""} {
set KeepInTFAs 0
set FichInTFAs ""
} else {
if {[regexp "^Keep" $KeepInTFAs]} {
set FichInTFAs ""
} else {
set FichInTFAs $KeepInTFAs
}
set KeepInTFAs 1
}
if {$KeepAnchors==""} {
set KeepAnchors 0
set FichAnchors ""
} else {
if {[regexp "^Keep" $KeepAnchors]} {
set FichAnchors ""
} else {
set FichAnchors $KeepAnchors
}
set KeepAnchors 1
}
if {$KeepLog==""} {
set KeepLog 0
set FichLog ""
} else {
if {[regexp "^Keep" $KeepLog]} {
set FichLog ""
} else {
set FichLog $KeepLog
}
set KeepLog 1
}
set CommandeDbClustal [set Commandes(dbclustal)]
if {[info exists MyDbClustal] && [info exists Commandes($MyDbClustal)]} {
set CommandeDbClustal [set Commandes($MyDbClustal)]
}
set Nom [file tail $Nom]
if {$Nom==""} { set Nom "dbctmp" }
set Racine [TmpFile $Nom]
if {$FichInTFAs==""} {
if {[EstUnPAB $Nom]} {
set FichInTFAs "$RepertoireDuGenome/tfasdescopains/$Nom"
} else {
set FichInTFAs "$Racine.inp"
}
}
set ButNo ""
if {[regexp "penelope" $RepertoireDuGenome]} {
regsub "^ABY" $Nom "PAB" PAB
if {[regexp "^PAB" $PAB]} { set ButNo $PAB }
}
if {[regexp "AvecSelection" $AvecQuoi]} {
set TexteTFA [ConcatLesTFAs $Source "ButNo:$ButNo"]
Sauve $TexteTFA dans $FichInTFAs
}
if {[regexp "AvecFichierTFA" $AvecQuoi]} {
set TexteTFA [ContenuDuFichier $Source]
if {$Source!=$FichInTFAs} { Sauve $TexteTFA dans $FichInTFAs }
}
if {[regexp "AvecTexteTFA" $AvecQuoi]} {
set TexteTFA $Source
Sauve $TexteTFA dans $FichInTFAs
}
if {[regexp -all ">" $TexteTFA] < 2} {
Warne " ... !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! NoSequencesToAlign"
return "NoSequencesToAlign"
}
NousAllonsAuBoulot
set Anchors [FichierAnchorsPour $Nom]
if { ! [file exists $Anchors]} {
Warne "$Anchors\nfile not found, I run dbclustal without anchors"
set Anchors ""
}
set Anchors [AnchorsCoherents $FichInTFAs $Anchors $Nom $Query]
set In "$Racine.inp"
set Out "$Racine.out"
set Log "$Racine.log"
File copy -force $FichInTFAs $In
Warne "$CommandeDbClustal\n $In\n $Out\n $Log\n $Anchors"
Warne " pour $Nom lance en interactif ... un peu de patience. Merci."
if {[catch { eval exec "$CommandeDbClustal $In $Out $Log $Anchors"} Message]} {
set Lolo "I got an error during DbClustal $Nom with following message\n$Message"
Warne $Lolo
AppendAuFichier $Log $Lolo
set Status "YaLog"
}
if { ! [file exists "$Out.msf"]} {
Warne [ContenuDuFichier $Log]
File copy -force $Log "$Out.log"
set Status "YaLog"
} else {
File rename -force $Out.msf $FichierMSF
if { ! $KeepInTFAs } { File delete -force $In }
if { ! $KeepAnchors} { File delete -force $Anchors }
if { ! $KeepLog } { File delete -force $Log }
set Status "OK"
}
if {$KeepInTFAs && $FichInTFAs!="" && [file exists $In]} { File copy -force $In $FichInTFAs }
if {$KeepAnchors && $FichAnchors!="" && [file exists $Anchors]} { File copy -force $Anchors $FichAnchors }
if {$KeepLog && $FichLog!="" && [file exists $Log]} { File copy -force $Log $FichLog }
Warne " ... j'ai fini. $Status"
OnRevientDuBoulot
return $Status
}
proc DbClustalEtMacsims {FichierTfa {FichierMsf ""} {FichierXml ""} {FichierRsf ""} {FichierLog ""} {Delete ""}} {
if { ! [regexp "^/" $FichierTfa]} { set FichierTfa "[pwd]/$FichierTfa" }
regsub ".tfa$" $FichierTfa "" Racine
if {$FichierMsf==""} { set FichierMsf "$Racine.msf" }
if {$FichierXml==""} { set FichierXml "$Racine.xml" }
if {$FichierRsf==""} { set FichierRsf "$Racine.rsf" }
if {$FichierLog==""} { set FichierLog "$Racine.log" }
if {[catch {set Status [DbClustal $Racine $FichierMsf $FichierTfa AvecFichierTFAs KeepInTFAs "" $FichierLog]} Message]} {
return "Error. Something went wrong during DbClustal. I got the message :\n$Message"
}
set LogDbClustal [ContenuDuFichier $FichierLog]
if {$Status!="OK"} { return "Error. I could'nt get the alignment" }
if {[catch {set Status [Macsims $FichierMsf $FichierXml $FichierRsf $FichierLog]} Message]} {
return "Error. Something went wrong during Macsims. I got the message :\n$Message"
}
Sauve "$LogDbClustal\n[ContenuDuFichier $FichierLog]" dans $FichierLog
foreach Mot [split $Delete "_"] {
set F "Fichier$Mot"
if {[regexp {\.$} $F]} {
set FSansPoint [string trimright $F "."]
if { ! [info exists $FSansPoint]} { continue }
foreach FF [glob -nocomplain "[set $FSansPoint].*"] {
file delete $FF
}
} else {
if { ! [info exists $F]} { continue }
foreach FF [glob -nocomplain "[set $F]*"] {
file delete $FF
}
}
}
return $Status
}
proc Alignons {PourQui {NomATraiter ""}} {
global RepertoireDuGenome
global ListeDesPABs
global NotreOS
set OnEffaceBallast 0
if {$NomATraiter == "" } {
set Liste [ListeDesPABs]
} else {
set Liste [list $NomATraiter]
}
if {$PourQui=="Paralogues"} {
set RepertoireMSF "$RepertoireDuGenome/msfparalogues"
File mkdir $RepertoireMSF
}
set Conserve 1
if {[llength [glob -nocomplain "$RepertoireMSF/*"]] > 0} {
set Conserve [OuiOuNon "Should I keep the existing files in $RepertoireMSF"]
}
foreach Nom $Liste {
Espionne "Je vais traiter $Nom"
set FichierMSF "$RepertoireMSF/$Nom"
set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"
if {$PourQui=="Paralogues" && [ParaloguesDe $Nom]=={}} { continue }
if { ! [file exists $FichierBlastP]} { continue }
if { $Conserve && [file exists $FichierMSF] } { continue }
if {[file exists "$RepertoireDuGenome/ballast/$Nom"]} {
set FichierBallast "$RepertoireDuGenome/ballast/$Nom"
} else {
set FichierBallast [Ballast $FichierBlastP]
}
if {$FichierBallast != "" && \
[regexp -nocase "fatal error" [join [LesPremieresLignesDuFichier $FichierBallast 10]] "\n"]} {
set FichierBallast ""
}
if {$PourQui=="Paralogues"} {
set LaSelectionUnique [ParaloguesDe $Nom "apn"]
EspionneL $LaSelectionUnique
Espionne [llength $LaSelectionUnique]
if {[llength $LaSelectionUnique] == 0} {
continue
}
} else {
set LaSelectionUnique [CreeLaListeLesCopains $FichierBlastP "blastp"]
if {[llength $LaSelectionUnique] == 0} {
Warne "$Nom pas de sequences a aligner"
Sauve "NoSequencesToAlign" dans $FichierMSF
continue
}
}
set Selection "$RepertoireDuGenome/protembl/$Nom $Nom 0.0 $NotreOS\n"
append Selection [join $LaSelectionUnique "\n"]
set StatusDbClustal [DbClustal $Nom $FichierMSF $Selection "AvecSelection"]
if {$OnEffaceBallast && [file exists $FichierBallast]} {
File delete -force $FichierBallast
foreach FichierBallastExt [glob -nocomplain "$FichierBallast.*"] {
File delete -force $FichierBallastExt
}
}
if {$StatusDbClustal=="OK"} { continue }
if {$StatusDbClustal=="PasDeSequencesAAligner"} {
Warne "$Nom pas de sequences a aligner ou erreur dans l'alignement."
Sauve "NoSequencesToAlignOrError" dans $FichierMSF
continue
}
if {$StatusDbClustal=="YaLog"} {
continue
}
}
}
proc RunDbClustal {Selection {NomOuFichierBlastP ""} {QuoiFaire ""}} {
JeMeSignale
global RepertoireDuGenome
global Commandes
Wup "Runs DbClustal on Selection (if wanted with the anchors of the blastpfile NomOuFichierBlastP)"
if {$QuoiFaire==""} { set QuoiFaire "ShowMsf" }
if { ! [regexp "\n" $Selection] && ! [regexp " " $Selection] && [regexp "/" $Selection]} {
set Selection [ContenuDuFichier $Selection]
}
if {[regexp "Query=" $Selection]} {
set Query [StringApres "Query=" dans $Selection]
} else {
set Query ""
}
set Nom "?"
set WithAnchors 0
if {$NomOuFichierBlastP!=""} {
set Nom [file tail $NomOuFichierBlastP]
set FichierBlastP $NomOuFichierBlastP
if { ! [file exists $FichierBlastP]} { set FichierBlastP "$RepertoireDuGenome/blastp/$Nom" }
if {[EstUnFichierBlastP $FichierBlastP]} {
set WithAnchors 1
}
if { ! [regexp "^/" $FichierBlastP]} {
set FichierBlastP "[pwd]/$FichierBlastP"
}
} else {
set FichierBlastP ""
}
NousAllonsAuBoulot
set Racine [TmpFile]
set Anchors ""
if {$WithAnchors} {
set RepBallast "$Racine.ballast"
File mkdir $RepBallast
set FichierBallast [Ballast $FichierBlastP $RepBallast $Query]
if {$FichierBallast != "" && \
[regexp -nocase "fatal error" [join [LesPremieresLignesDuFichier $FichierBallast 10]] "\n"]} {
set FichierBallast ""
}
set Anchors "$FichierBallast.anchors"
if { ! [file exists $Anchors]} {
Warne "$Anchors\nfile not found, I run dbclustal without anchors"
set Anchors ""
}
}
set In "$Racine.inp"
set Out "$Racine.out"
set Log "$Racine.log"
if {$Anchors!=""} {
set Anc "$Racine.anchors"
File copy $Anchors $Anc
} else {
set Anc ""
}
if {[regexp "^>" $Selection]} {
set TFAaAligner $Selection
} else {
set TFAaAligner [ConcatLesTFAs $Selection]
}
Sauve $TFAaAligner dans $In
if {$Anc!=""} {
set Anc [AnchorsCoherents $In $Anc $FichierBlastP]
}
if {[regexp -nocase "Get" $QuoiFaire]} { set Mode "Interactif" } else { set Mode "Batch" }
if {$Mode=="Batch"} {
catch {set Canal [open "| [set Commandes(dbclustal)] $In $Out $Log $Anc"]} Message
fconfigure $Canal -blocking false -buffering line
fileevent $Canal readable "ClosCanalEtMontreMSF dbclustal $Canal $Out.msf $Log"
Warne "dbclustal est lance en batch"
OnRevientDuBoulot
return "$Out.msf"
}
Warne "DbClustal sur $Nom lance en interactif ... un peu de patience. Merci."
eval exec "[set Commandes(dbclustal)] $In $Out $Log $Anc"
Warne " ... j'ai fini."
if { ! [file exists "$Out.msf"]} {
if {$QuoiFaire=="GetMsfText" || $QuoiFaire=="GetMsfFilename"} { return "" }
set Fenetre [AfficheVariable [ContenuDuFichier $Log] "AvecRien" $Log]
} else {
if {$QuoiFaire=="GetMsfText"} {
return [ContenuDuFichier $Out.msf]
}
if {$QuoiFaire=="GetMsfFilename"} {
return $Out.msf
}
set Fenetre [AfficheVariable [ContenuDuFichier $Out.msf] "AvecEtudeMSFGrandeLargeur" $Out.msf ]
}
foreach Fichier [glob -nocomplain "$Racine.*"] {
if {$Fichier=="$Out.msf"} { continue }
if {$Fichier=="$Anc"} { continue }
# File delete -force $Fichier
}
OnRevientDuBoulot
return $Fenetre
}
proc TestAnchorsCoherents {} {
global RepertoireDuGenome
set FichierTFA "$RepertoireDuGenome/tfasdescopains/PDB66"
set FichierAnchors "$RepertoireDuGenome/ballast/PDB66.anchors"
set FichierBlast "$RepertoireDuGenome/blastp/PDB66"
Espionne [AnchorsCoherents $FichierTFA $FichierAnchors $FichierBlast]
exit
}
proc AnchorsCoherents {FichierTFA FichierAnchors NomOuFichierBlast {Query ""}} {
global RepertoireDuGenome
JeMeSignale
Wup "If the names in the TFA and Anchors don't correspond I change in the TFA"
Wup " in Ballast I do otherwize and change in the Anchor file."
if { ! [regexp -nocase {[0-9a-z_]} $FichierAnchors]} { return "" }
foreach Ligne [LesLignesDuFichier $FichierTFA] {
if { ! [regexp "^>" $Ligne]} { continue }
regsub ">" $Ligne "" Ligne
scan $Ligne "%s" AccessTFA
set ACCESSTFA [string toupper $AccessTFA]
set EstDansTFA($ACCESSTFA) 1
set Beau($ACCESSTFA) $AccessTFA
}
set ChangeQuery 0
set LesAnchorsAChanger {}
foreach Ligne [LesLignesDuFichier $FichierAnchors] {
if { ! [regexp "^seq\:" $Ligne]} { continue }
set AccessAnchor ""
scan $Ligne "%s %s %s" Seq QueryLue AccessAnchor
if {$Query!="" && $QueryLue!=$Query} { set ChangeQuery 1; set BETTERQUERY($QueryLue) $Query }
set ACCESSANCHOR [string toupper $AccessAnchor]
if {[info exists EstDansTFA($ACCESSANCHOR)]} { continue }
set MauvaisAnchors($ACCESSANCHOR) 1
lappend LesAnchorsAChanger $AccessAnchor
}
if {$LesAnchorsAChanger=={} && ! $ChangeQuery} { return $FichierAnchors }
set FichierBlast $NomOuFichierBlast
if { ! [regexp "/" $NomOuFichierBlast] || ! [file exists $FichierBlast]} {
set Nom $NomOuFichierBlast
set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
}
if { ! [file exists $FichierBlast]} { return $FichierAnchors }
DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
foreach BanqueId $lBanqueId Access $lAccess {
regsub {\:} $BanqueId "|" BanqueId
if {[regexp "mol\:protein" $Access]} { set Access $BanqueId }
set BANQUEID [string toupper $BanqueId]
set ACCESS [string toupper $Access]
if {[info exists DejaVu($BANQUEID)] || [info exists DejaVu($ACCESS)]} {
FaireLire "Deja vu $BanqueID $Access !! "
}
set Beau($BANQUEID) $BanqueId
set Beau($ACCESS) $Access
if {$BANQUEID!=$ACCESS} {
set Autre($BANQUEID) $ACCESS
set Autre($ACCESS) $BANQUEID
}
}
set NouveauxAnchors {}
foreach Ligne [LesLignesDuFichier $FichierAnchors] {
set NouvelleLigne $Ligne
if { ! [regexp "^seq\:" $Ligne]} { lappend NouveauxAnchors $NouvelleLigne ; continue }
set AccessAnchor ""
scan $NouvelleLigne "%s %s %s" Seq QueryLue AccessAnchor
if {[info exists BETTERQUERY($QueryLue)]} {
set Better $BETTERQUERY($QueryLue)
if {[regexp -indices $QueryLue $NouvelleLigne Indices]} {
lassign $Indices D F
set L [string length $Better]
if {$L>=$F-$D+1} {
set F [expr $D+$L-1]
} else {
set L [expr $F-$D]
set Better [string range "$Better " 0 $L]
}
set NouvelleLigne [string replace $NouvelleLigne $D $F $Better]
}
}
set ACCESSANCHOR [string toupper $AccessAnchor]
if { ! [info exists MauvaisAnchors($ACCESSANCHOR)]} {
lappend NouveauxAnchors $NouvelleLigne
continue
}
if { ! [info exists Autre($ACCESSANCHOR)]} {
if { [EstUnAccessPDB $ACCESSANCHOR] && [regexp "_$" $ACCESSANCHOR]} {
regsub "_$" $ACCESSANCHOR "" AUTREACC
} else {
lappend NouveauxAnchors $Ligne
continue
}
} else {
set AUTREACC [set Autre($ACCESSANCHOR)]
}
if { ! [info exists EstDansTFA($AUTREACC)]} {
lappend NouveauxAnchors $NouvelleLigne
continue
}
set BeauNouveau [set Beau($AUTREACC)]
set NouvelleLigne [SubstitueAvecBlancsDevant $NouvelleLigne $AccessAnchor $BeauNouveau]
lappend NouveauxAnchors $NouvelleLigne
}
SauveLesLignes $NouveauxAnchors dans "$FichierAnchors.coherent2"
return [SauveLesLignes $NouveauxAnchors dans "$FichierAnchors.coherent"]
}
proc FichierAnchorsPour Nom {
global RepertoireDuGenome
global OptionsBallastPourJulie
set FichierAnchors "$RepertoireDuGenome/ballast/$Nom.anchors"
if {[file exists $FichierAnchors]} { return $FichierAnchors }
Wup "Il faut le creer"
set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"
if { ! [file exists $FichierBlastP]} { return "" }
if { ! [info exists OptionsBallastPourJulie] \
&& [file exists "$RepertoireDuGenome/ballast/$Nom"]} {
set FichierBallast "$RepertoireDuGenome/ballast/$Nom"
} else {
set FichierBallast [Ballast $FichierBlastP]
}
if {$FichierBallast != "" && \
[regexp -nocase "fatal error" [join [LesPremieresLignesDuFichier $FichierBallast 10]] "\n"]} {
set FichierBallast ""
}
if {$FichierBallast==""} { return "" }
return "$FichierBallast.anchors"
}
proc LesOrganismesImportantsPourDBClustal {{Ask ""}} {
global RepertoireDuGenome
global GscopeDir
global LesOrganismesImportantsPourDBClustal
set Ask [regexp -nocase "^Ask$" $Ask]
if {! $Ask && [info exists LesOrganismesImportantsPourDBClustal]} {
return $LesOrganismesImportantsPourDBClustal
}
set FichierOrgImportant "$RepertoireDuGenome/fiches/orgimportant"
if {$Ask || ! [file exists $FichierOrgImportant]} {
set FichierOrgImportantDefaut "$GscopeDir/gscope_orgimportant"
if {[file exists $FichierOrgImportantDefaut] && \
[OuiOuNon "Do I copy the file \n\
$FichierOrgImportantDefaut\n\
to $FichierOrgImportant\n ?"]} {
File copy $FichierOrgImportantDefaut $FichierOrgImportant
} else {
while {[OuiOuNon "Do You want to load an existing file with Important Organisms ?"]} {
set F [ButineArborescence "All" $RepertoireDuGenome]
if {$F==""} { continue }
if {[OuiOuNon "Do I copy it to $FichierOrgImportant ?"]} {
File copy -force $F $FichierOrgImportant
} else {
set FichierOrgImportant $F
}
break
}
}
}
if {[file exists $FichierOrgImportant]} {
set LesOIs [LesLignesDuFichier $FichierOrgImportant]
} else {
lappend LesOIs "### Important organisms for DBClustal"
lappend LesOIs "# You can modify these lines."
lappend LesOIs "# please respect Upper-lower case ( Homo sapiens )"
lappend LesOIs "# use 'remove' to remove an organism."
lappend LesOIs "# nothing to add a new organism."
lappend LesOIs "# use 'addall' to tell to Gscope to add all these returned by the function"
lappend LesOIs "# use 'remall' to tell to Gscope to remove these"
lappend LesOIs "#"
lappend LesOIs "# If one organism appears two times, the first command has priority"
lappend LesOIs "###"
lappend LesOIs "Pyrococcus furiosus"
lappend LesOIs "remove Pyrococcus furiosus"
lappend LesOIs "remove Homo sapiens"
lappend LesOIs "Homo sapiens"
lappend LesOIs "addall LesGenomesComplets"
set Ask 1
}
while {$Ask && [OuiOuNon "Do You want to edit the Important Organisms List ?" 0]} {
set OIs [EntreTexte [join $LesOIs "\n"]]
if {$OIs==""} { continue }
set LesOIs [split $OIs "\n"]
if {[OuiOuNon "Do I save these organisms in \n $FichierOrgImportant ?"]} {
SauveLesLignes $LesOIs dans $FichierOrgImportant
}
break
}
set LesOrganismesImportants {}
foreach Ligne $LesOIs {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
if {[regexp " *#+" $Ligne]} { continue }
if {[regexp "^(addall |remall )" $Ligne Match]} {
set Commande [StringSuivant "$Match" dans $Ligne]
foreach O [eval $Commande] {
if {[info exists DejaVu($O)]} { continue }
set DejaVu($O) 1
if {$Match=="addall "} { lappend LesOrganismesImportants $O }
}
continue
}
set RemoveMoi [regexp "^remove " $Ligne]
regsub "^remove +" $Ligne "" O
if {[info exists DejaVu($O)]} { continue }
set DejaVu($O) 1
if {$RemoveMoi} { continue }
lappend LesOrganismesImportants $O
}
set LesOrganismesImportantsPourDBClustal $LesOrganismesImportants
return $LesOrganismesImportants
}
proc TailleSortiePourDBClustal {{Ask ""}} {
global RepertoireDuGenome
global GscopeDir
global TailleSortiePourDBClustal
set Ask [regexp -nocase "^Ask$" $Ask]
if {! $Ask && [info exists TailleSortiePourDBClustal]} {
return $TailleSortiePourDBClustal
}
set FichierTailleSortie "$RepertoireDuGenome/fiches/sizemsf"
if { $Ask || ! [file exists $FichierTailleSortie]} {
set FichierTailleSortieDefaut "$GscopeDir/gscope_sizemsf"
if {[file exists $FichierTailleSortieDefaut] && \
[OuiOuNon "Do I copy the file \n\
$FichierTailleSortieDefaut\n\
to $FichierTailleSortie\n ?"]} {
File copy $FichierTailleSortieDefaut $FichierTailleSortie
} else {
while {[OuiOuNon "Do You want to load an existing file with output sizes for dbclustal ?"]} {
set F [ButineArborescence "All" $RepertoireDuGenome]
if {$F==""} { continue }
if {[OuiOuNon "Do I copy it to $FichierTailleSortie ?"]} {
File copy -force $F $FichierTailleSortie
} else {
set FichierTailleSortie $F
}
break
}
}
}
if {[file exists $FichierTailleSortie]} {
set VT [ContenuDuFichier $FichierTailleSortie]
} else {
set VT "40 70 30 0.001 respectively : at_least max_with_complete_genomes max_pdb expect"
set Ask 1
}
while {$Ask && [OuiOuNon "Do You want to modify the output sizes ?"]} {
set NewVT [Entre $VT]
if {$NewVT==""} { continue }
set VT $NewVT
if {[OuiOuNon "Do I save these values in $FichierTailleSortie ?"]} {
Sauve $VT dans $FichierTailleSortie
}
}
set TailleSortiePourDBClustal $VT
return $VT
}
proc LesCandidatsPourClustalW {FichierOuNom {Source ""}} {
global RepertoireDuGenome
global SeuilExpectPourJulie
if {$Source==""} { set Source "blastp" }
set Nom [file tail $FichierOuNom]
scan [TailleSortiePourDBClustal] "%d %d %d %f" MinObliges MaxVoulus MaxPDB SeuilExpect
if {[info exists SeuilExpectPourJulie]} {
set SeuilExpect $SeuilExpectPourJulie
}
Wup "On ne veut plus voir le meme PAB .......... peut servir autrement ... "
set LesIndesirables {}
if {0 && [regsub "^ABY$" $Nom "PAB" Indesirable]} {
lappend LesIndesirables $Indesirables
}
if { $Source=="apnosoc"} {
set FichierApnOsOc "$RepertoireDuGenome/apnosoc/$Nom"
if {[file exists $FichierApnOsOc]} {
set LesCandidats [LesLignesDuFichier "$RepertoireDuGenome/apnosoc/$Nom"]
} else {
return {}
}
} elseif { $Source=="blastp" || $Source=="ballast"} {
set LesCandidats {}
if {[file exists $FichierOuNom]} {
set FichierBallast $FichierOuNom
} else {
set FichierBallast "$RepertoireDuGenome/$Source/$Nom"
}
if { ! [file exists $FichierBallast]} { return {} }
DecortiqueBlast $FichierBallast $SeuilExpect "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
PrepareLesSequencesDesBanques $lBanqueId $lAccess
foreach BanqueId $lBanqueId Access $lAccess Profil $lProfil PN $lPN {
set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
if {[lsearch -exact $LesIndesirables $Access] > 0 } { continue }
Wup "Si ballast, on ne prend que ceux qui ont contribue au profil"
if {0 && $Source=="ballast" && ! $Profil} { continue }
lappend LesCandidats "$BanqueId $Access $PN $OS $OC"
regsub -all {\:} $DE "_" DE
set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX: $OX"
StockeLeDescriptif $AccessOK $Descriptif $Nom
}
}
return $LesCandidats
}
proc ReordonneLeFichierMSF {Fichier LesAccess {Nom ""}} {
if { ! [file exists $Fichier]} {
set Fichier "[RepertoireDuGenome]/msf/$Fichier"
}
if { ! [file exists $Fichier]} { return "" }
if {$Nom==""} { set Nom [file tail $Fichier] }
set MSF [ContenuDuFichier $Fichier]
return [ReordonneMSF $MSF $LesAccess $Nom]
}
proc ReordonneMSF {MSF LesAccess {Nom ""}} {
while 1 {
if {$Nom!="" && $LesAccess=="Disphy"} {
set LesAccess [concat [list $Nom] [FromDisphy $Nom]]
break
}
if {$LesAccess=="Secator"} {
set FiMSF [Sauve $MSF dans [TmpFile "secator"]]
set LesAccess [GroupeSecator $FiMSF "" "ToutLeMondeAvecGroupe" "ToCalculate"]
break
}
if {$LesAccess=="Dpc"} {
FaireLire "It's not yet possible to reorder with Dpc"
return ""
set FiMSF [Sauve $MSF dans [TmpFile "dpc"]]
set LesAccess [GroupeDpc $FiMSF "" "ToutLeMondeAvecGroupe" "ToCalculate"]
break
}
if {$LesAccess=="Oumy"} {
FaireLire "It's not yet possible to reorder with Oumy"
return ""
set FiMSF [Sauve $MSF dans [TmpFile "oumy"]]
set LesAccess [GroupeOumy $FiMSF "" "ToutLeMondeAvecGroupe" "ToCalculate"]
break
}
break
}
set i 0
foreach Ligne $LesAccess {
scan $Ligne "%s" Access
set ACCESS [string toupper $Access]
set RangDuAccess($ACCESS) [incr i]
}
set LeMSF [split $MSF "\n"]
lappend LeMSF "UneLignePourFinir"
foreach Ligne $LeMSF {
if { ! [regexp -nocase {[a-z]+} $Ligne] || \
[regexp "^PileUp|MSF: " $Ligne]} {
if {[info exists GroupeCourant]} {
set GroupeCourant [lsort -integer -index 0 $GroupeCourant]
foreach iLi $GroupeCourant {
set Li [lindex $iLi 1]
lappend LeNouveau $Li
}
unset GroupeCourant
}
if {$Ligne=="UneLignePourFinir"} { break }
lappend LeNouveau $Ligne
continue
}
scan $Ligne "%s %s" Name Access
if {$Name!="Name:"} { set Access $Name }
set ACCESS [string toupper $Access]
if {[info exists RangDuAccess($ACCESS)]} {
lappend GroupeCourant [list [set RangDuAccess($ACCESS)] $Ligne]
}
}
return [join $LeNouveau "\n"]
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.