Index by: file name |
procedure name |
procedure call |
annotation
gscope_sequence.tcl
(annotations | original source)
#rR Debut de gscope_sequence.tcl
proc QueLaSequenceDesBanquesDeLaListe Liste {
set Liste [split $Liste " ,;\n\t"]
set LeResultat {}
foreach Access $Liste {
set Seq [QueLaSequenceDesBanques $Access]
regsub -all -nocase {[^a-z]} $Seq "" Seq
lappend LeResultat "$Access $Seq"
}
return $LeResultat
}
proc TFAsFromAccessList {ListeOuFichier {GetWhat ""}} {
if {[regexp "\n" $ListeOuFichier]} {
set ListeOuFichier [split ListeOuFichier "\n"]
}
if {[llength $ListeOuFichier]==1 && [file exists $ListeOuFichier]} {
set ListeOuFichier [LesLignesVitales $ListeOuFichier "SansVide"]
}
set LeTFAs {}
set Liste $ListeOuFichier
foreach Ligne $Liste {
scan $Ligne "%s" Access
set Embl [SequenceDesBanques $Access]
if {$Embl==""} { Warne "Je laisse tomber $Access :'(" ; continue }
set TFA [SequenceFormatTFA $Embl $Access]
lappend LeTFAs $TFA
}
if {$GetWhat=="GetList"} { return $LeTFAs }
if {$GetWhat=="GetText"} { return [join $LeTFAs "\n"] }
return [SauveLesLignes $LeTFAs dans $GetWhat]
}
proc TestCdsFromNM {} {
set Fasta [eFetchREST nucleotide "NM_019955 AI852232 NM_019778" cds]
Espionne $Fasta
}
proc CdsFromNM {ListeDesNM {Organisme ""}} {
#rR on appelle eFetchREST de Luc qui interroge le NCBI avec une liste de NM
#rR attention je manipule des liste paralelles ... s'il y a un absent son élément est vide
regsub -all {[ \n\t,]+} $ListeDesNM " "
set ListeDesNM [string trim $ListeDesNM]
set ListeDesNM [split $ListeDesNM " "]
set NbNM [llength $ListeDesNM]
set Fasta [eFetchREST "nucleotide" $ListeDesNM cds]
set i 0
set AEnfiler 0
set LesCds {}
set OkNM 0
foreach Ligne [split $Fasta "\n"] {
if {[string trim $Ligne]==""} { continue }
if {[regexp "^Error" $Ligne]} { continue }
if {[regexp ">" $Ligne]} {
if { $AEnfiler } { lappend LesCds $Courant; set AEnfiler 0 }
set OkNM 0
while {$i<$NbNM} {
set NM [lindex $ListeDesNM $i]
incr i
if { ! [regexp $NM $Ligne]} { set OkNM 0; lappend LesCds ">NotFound_$NM"; continue }
set OkNM 1
break
}
if {! $OkNM} { break }
set AEnfiler 1
scan [string trimleft $Ligne ">"] "%s" Access
set Access [lindex [split $Access "|"] end]
set Gene ""
if {[regexp {\[gene=([^\]]+)\]} $Ligne Match X]} { set Gene $X }
set Def ""
if {[regexp {\[protein=([^\]]+)\]} $Ligne Match X]} { set Def $X }
set ProteinId ""
if {[regexp {\[protein_id=([^\]]+)\]} $Ligne Match X]} { set ProteinId $X }
if {$Gene==""} { set Gene $Access }
set Entete ">$Gene $Organisme $Def $ProteinId $Access"
set Courant $Entete
} else {
if {$OkNM} { append Courant "\n$Ligne" }
}
}
if { $AEnfiler } { lappend LesCds $Courant }
return $LesCds
}
proc Sequence {Access {Alias ""}} {
#rR a ameliorer !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if {$Alias!=""} { return [QueLaSequenceDuAlias $Access "prottfa"] }
set EMBL [SequenceDesBanques $Access]
set Seq [QueLaSequenceDuTexteEMBL $EMBL]
return $Seq
}
proc ExtraitGenesDuGlimmer {FichierAdn FichierGlimmer Prefixe Repertoire} {
# on met x au debut pour avoir une numerotation a partir de 1 (et non pas 0)
set SeqAdn "x"
foreach Ligne [LesLignesDuFichier $FichierAdn] {
if {[regexp ">" $Ligne]} { continue }
regsub -all -nocase {[^A-Z]} $Ligne "" Ligne
append SeqAdn $Ligne
}
set LesFichiersCrees {}
foreach Ligne [LesLignesDuFichier $FichierGlimmer] {
scan $Ligne "%d %d %d %s" N Debut Fin Frame
if {[regexp {\+} $Frame]} { set Orient "F" } else { set Orient "R" }
set Nom [format "%s%4.4d" $Prefixe $N]
if {$Debut>$Fin} { set w $Debut; set Debut $Fin; set Fin $w }
set Sequence [string range $SeqAdn $Debut $Fin]
#il manque quelque chose ici
set Long [string length $Sequence]
set Entete ">$Nom $Debut $Fin $Orient $Long bp"
set Texte $Entete
set SeqRestante $Sequence
while {[set Morceau [string range $SeqRestante 0 59]] != ""} {
append Texte "\n$Morceau"
set SeqRestante [string range $SeqRestante 60 end]
}
set FichierCree "$Repertoire/$Nom"
# Sauve $Texte dans $FichierCree
lappend LesFichiersCrees $FichierCree
}
return $LesFichiersCrees
}
proc PremierENSP0DuBlast {TexteOuFichier {GetWhat ""}} {
return [PremierAccessCommeJeVeuxDuBlast $TexteOuFichier "ENSP0" $GetWhat]
}
proc PremierAccessCommeJeVeuxDuBlast {TexteOuFichier {Modele ""} {Quoi ""}} {
if {$Quoi==""} { set Quoi "GetAccess" }
if {[regexp "\n" $TexteOuFichier]} {
set Texte $TexteOuFichier
} else {
if {[EstUnPAB $TexteOuFichier]} { set TexteOuFichier [GscopeFile $TexteOuFichier "blastp"] }
set Texte [ContenuDuFichier $TexteOuFichier]
}
set LesLignes [split $Texte "\n"]
set IndexSPSA [lsearch -regexp $LesLignes "Sequences producing significant alignments"]
if { $IndexSPSA > -1 } { set LesLignes [lrange $LesLignes [incr IndexSPSA 1] end] }
set Texte [join $LesLignes "\n"]
if { ! [regexp -nocase "\n(($Modele\[^ \]+) \[^\n\]+)\n" $Texte Match Ligne Access]} { return "" }
if {[string equal -nocase $Quoi "GetExpect"]} {
if { ! [regexp { ([^ ]+) *$} $Ligne Match Expect]} { return "" }
return $Expect
}
if {[string equal -nocase $Quoi "GetLine"]} { return $Ligne }
return $Access
}
proc LOFtoTFAs {ListOfFiles {UseFilename ""}} {
if {$UseFilename==""} { set UseFilename "UseFileName" }
set UseFilename [string equal -nocase $UseFilename "UseFilename"]
set LesTFAs {}
foreach Fichier $ListOfFiles {
if {[FileAbsent $Fichier]} {
FaireLire "$Fichier\ndoesn't exist ... I'll skip it."
continue
}
set Nom ""
if {$UseFilename} { set Nom [file tail $Fichier] }
set TFA [SequenceFormatTFA [ContenuDuFichier $Fichier] $Nom]
lappend LesTFAs $TFA
}
return [join $LesTFAs "\n"]
}
proc FOFtoTFAs {FichierDeNomsDeFichier {UseFilename ""}} {
return [LOFtoTFAs [LesLignesDuFichier $FichierDeNomsDeFichier]]
}
proc MsfToTfa {FichierMsf {FichierTfa ""}} {
set GetWhat "GetFile"
set DeleteTfa 0
set DeleteMsf 0
if {[regexp "\n" $FichierMsf]} {
set FichierMsf "[TmpFile].msf"
set DeleteMsf 1
}
if {$FichierTfa==""} {
regsub -nocase {\.msf$} $FichierMsf "" FichierTfa
append FichierTfa ".tfa"
}
if {$FichierTfa=="GetTfa"} {
set GetWhat "GetTfa"
set FichierTfa "[TmpFile].tfa"
set DeleteTfa 1
}
exec clustalw $FichierMsf -convert -output=FASTA -outfile=$FichierTfa
set Retour $FichierTfa
if {$FichierTfa=="GetTfa"} {
set Retour [ContenuDuFichier $FichierTfa]
}
if {$DeleteTfa} { file delete $FichierTfa }
if {$DeleteMsf} { file delete $FichierMsf }
return $Retour
}
proc TestLKI {} {
set Texte [ContenuDuFichier "[RepertoireDuGenome]/protemblRecupere/EVI03681"]
LesKeywordsInteressantsDuGenbank $Texte T LOCUS DEFINITION SOURCE FEATURES
Espionne $T(DEFINITION)
Espionne $T(SOURCE)
Espionne $T(FEATURES)
}
proc OrganismeCanoniqueDuGenbank {TexteOuFichier} {
set Genre "Inconnu"
set Espece "inconnu"
set Organism [LesSubKeywordsInteressantsDuGenbank $TexteOuFichier bidon SOURCE ORGANISM]
scan $Organism "%s %s %s" machin Genre Espece
return "$Genre $Espece"
}
proc LesKeywordsInteressantsDuGenbank {TexteOuFichier aTab args} {
if {[regexp "\n" $TexteOuFichier]} {
set Texte $TexteOuFichier
} else {
set Texte [ContenuDuFichier $TexteOuFichier]
}
upvar $aTab Tab
set LesKW $args
foreach KW $LesKW {
set Tab($KW) ""
}
foreach Ligne [split $Texte "\n"] {
if {[regexp {^[^ ]} $Ligne]} {
scan $Ligne "%s" KW
set Interessant [expr [lsearch $LesKW $KW] > -1]
if {$Interessant} {set Tab($KW) "" ; set Sep ""}
}
if {$Interessant} {
append Tab($KW) "$Sep$Ligne"
set Sep "\n"
}
}
if {[llength $LesKW]==1} { return $Tab([lindex $LesKW 0]) }
return $LesKW
}
proc LesSubKeywordsInteressantsDuGenbank {TexteOuFichier aTab KW args} {
if {[regexp "\n" $TexteOuFichier]} {
set Texte $TexteOuFichier
} else {
set Texte [ContenuDuFichier $TexteOuFichier]
}
set Texte [LesKeywordsInteressantsDuGenbank $Texte Bidon $KW]
upvar $aTab Tab
set LesSKW $args
foreach SKW $LesSKW {
set Tab($SKW) ""
}
foreach Ligne [split $Texte "\n"] {
if { ! [regexp {^ } $Ligne]} {
scan $Ligne "%s" SKW
set Interessant [expr [lsearch $LesSKW $SKW] > -1]
if {$Interessant} {set Tab($SKW) "" ; set Sep ""}
}
if {$Interessant} {
append Tab($SKW) "$Sep$Ligne"
set Sep "\n"
}
}
if {[llength $LesSKW]==1} { return $Tab([lindex $LesSKW 0]) }
return $LesSKW
}
proc QueLaSequenceDesBanques {BanqueId {Access ""}} {
set EMBL [SequenceDesBanques $BanqueId $Access "" "OnVeutEMBL"]
return [QueLaSequenceDuTexteEMBL $EMBL]
}
proc QueLaSequenceADNDuAccessRefseq Access {
set Texte [Getz $Access refseq]
return [QueLaSequenceADNDuTexteGenbank $Texte]
}
proc QueLaSequenceADNDuTexteGenbank Texte {
return QueLaSequenceDuTexteGenbank $Texte
}
proc QueLaSequenceDuFichierGenbank Fichier {
return [QueLaSequenceDuTexteGenbank [ContenuDuFichier $Fichier]]
}
proc QueLaSequenceDuTexteGenbank Texte {
set OnAttendOrigine 1
foreach Ligne [split $Texte "\n"] {
if {$OnAttendOrigine} {
if {[regexp {^ORIGIN} $Ligne]} { set OnAttendOrigine 0 ; continue }
continue
}
lappend LesLignes $Ligne
}
if {$OnAttendOrigine} {
FaireLire "No sequence in the Genbank Texte\n\$Texte"
return ""
}
set Seq [join $LesLignes ""]
if {[regexp -nocase {[^[0-9 a-z/]} $Seq]} {
FaireLire "Bad sequence in the Genbank Texte\n\$Texte"
return ""
}
regsub -all {[^a-z]} $Seq "" Seq
return $Seq
}
proc TexteTfaFromTexteTfaWithoutNumbers TexteTFA {
set Seq [QueLaSequenceDuTexteTFA $TexteTFA]
set Ent [EnteteDuTexteTFA $TexteTFA]
set NouveauTexteTFA [SequenceFormatTFA $Seq $Ent]
return $NouveauTexteTFA
}
proc FichierTfaFromFichierTfaWithoutNumbers {FichierTFA {NouveauFichierTFA ""}} {
if {$NouveauFichierTFA==""} {
set NouveauFichierTFA [FichierPourSaveAs $FichierTFA]
}
if {$NouveauFichierTFA=="SameFile"} {
set NouveauFichierTFA $FichierTFA
}
set TexteTFA [ContenuDuFichier $FichierTFA]
set NouveauTFA [TexteTfaFromTexteTfaWithoutNumbers $TexteTFA]
return [Sauve $NouveauTFA dans $NouveauFichierTFA]
}
proc TLSDB {} {
EspionneL [LaSequenceDesBanques VARSPLIC:Q15911-2 Q15911-2 A]
Espionne $A
exit
}
proc LesAcsDuId ID {
set LesLignesEMBL [LaSequenceDesBanques $ID "" "OnVeutEMBL"]
if {$LesLignesEMBL==""} { return {} }
set LesACs {}
foreach Ligne $LesLignesEMBL {
if { ! [regexp "^AC " $Ligne]} {
if {$LesACs=={}} { continue } else { return $LesACs }
}
regsub "^AC " $Ligne "" Ligne
regsub ";" $Ligne " " Ligne
LConcat LesACs [LesMotsDeLaLigne $Ligne]
}
return $LesACs
}
proc IdDuAc AC {
set LesLignesEMBL [LaSequenceDesBanques $AC "" "OnVeutEMBL"]
if {$LesLignesEMBL==""} { return "" }
set ID [StringApres "ID " dans [lindex $LesLignesEMBL 0]]
return $ID
}
#rR a enlever si on est sûr qu'il n'y a plus de TFADe...
proc TFADeLaBanqueBlast {Banque Access} {
return [TfaDeLaBanqueBlast $Banque $Access]
}
proc TfaDeLaBanqueBlast {Banque Access} {
#set Banque [string tolower $Banque]
set TfaDeLaBanqueBlast ""
if {[catch { set TfaDeLaBanqueBlast [exec fastacmd -d $Banque -s $Access 2> /dev/null] } Message]} { }
#rR Rajout du 2014/11/10 car il y a PDB:
if {$TfaDeLaBanqueBlast!=""} { return $TfaDeLaBanqueBlast }
#Warne $Message
if { ! [regexp {^[0-9]} $Access]} { return "" }
catch { set TfaDeLaBanqueBlast [exec fastacmd -d $Banque -s "PDB:$Access" 2> /dev/null] } Message
return $TfaDeLaBanqueBlast
}
proc EstUneEnteteTFA Ligne {
set PremierMot ""
scan $Ligne "%s" PremierMot
return [regexp {^>[^>]*$} $PremierMot]
}
proc EstUnFichierTFA {Fichier {OuTFAs ""}} {
if { $Fichier == "" } {return 0}
set OuTFAs [string equal $OuTFAs "OuTFAs"]
set f [open $Fichier r]
if {[gets $f Ligne]<0 || ! [EstUneEnteteTFA $Ligne] } { close $f ; return 0}
set OnExigeSequence 1
set nChevrons 1
while {[gets $f Ligne]>=0} {
if { ! [regexp -nocase {[^a-z \t]} $Ligne]} {
set OnExigeSequence 0
continue
}
if {[regexp {>} $Ligne]} {
incr nChevrons
if { $OnExigeSequence || ! $OuTFAs} { close $f ; return 0 }
if { ! [EstUneEnteteTFA $Ligne] } { close $f ; return 0}
set OnExigeSequence 1
continue
} else {
close $f ; return 0
}
}
close $f ; return $nChevrons
}
proc UnSeulGetz Texte {
set Prem [string first "\n//" $Texte]
set Dern [string last "\n//" $Texte]
if {$Prem==$Dern} { return $Texte }
set AvDe [string last "\n//" $Texte [incr Dern -3]]
return "[string range $Texte [incr AvDe 3] end]"
}
proc PlusProcheOrganismeDuNarcissePourTous {} {
set FichierOrganismesDesPABs "[RepertoireDuGenome]/fiches/organismesdespabs"
if {[file exists $FichierOrganismesDesPABs]} {
foreach Ligne [LesLignesDuFichier $FichierOrganismesDesPABs] {
scan $Ligne "%s" NomLu
set DejaVu($NomLu) 1
}
}
foreach Nom [ListeDesPABs] {
if {[info exists DejaVu($Nom)]} { continue }
set Narcisse [Narcisse $Nom]
if {$Narcisse=="" || $Narcisse==$Nom} { continue }
set OS [OrgaDuAccess $Narcisse]
if {$OS==""} { continue }
AppendAuFichier $FichierOrganismesDesPABs "$Nom $OS"
}
return $FichierOrganismesDesPABs
}
proc PlusProcheOrganismeDuBlastPourTous {} {
set FichierOrganismesDesPABs "[RepertoireDuGenome]/fiches/organismesdespabs"
if {[file exists $FichierOrganismesDesPABs]} {
foreach Ligne [LesLignesDuFichier $FichierOrganismesDesPABs] {
scan $Ligne "%s" NomLu
set DejaVu($NomLu) 1
}
}
foreach Nom [ListeDesPABs] {
if {[info exists DejaVu($Nom)]} { continue }
set OS [PlusProcheOrganismeDuBlast $Nom]
AppendAuFichier $FichierOrganismesDesPABs "$Nom $OS"
}
return $FichierOrganismesDesPABs
}
proc PlusProcheOrganismeDuBlast NomOuFichierBlast {
global RepertoireDuGenome
if {[regexp "/" $NomOuFichierBlast]} {
set FichierBlast $NomOuFichierBlast
set Nom [file tail $NomOuFichierBlast]
} else {
set Nom $NomOuFichierBlast
set FichierBlast "[RepertoireDuGenome]/blastp/$Nom"
}
set Var 0.0
if {![file exists $FichierBlast]} {return ""}
DepouilleLeBlast TabBlast $FichierBlast
if {![info exists TabBlast(NbSubject)]} {return ""}
set LesProteines {}
set NMax 0
set NbSubject [set TabBlast(NbSubject) ]
for {set i 1} {$i <= $NbSubject} {incr i} {
set BIdProt [set TabBlast($i) ]
set N [NombreDeBasesEnCommun_TabBlast TabBlast $BIdProt]
set Id [PourcentageDIdentiteGlobal_TabBlast TabBlast $BIdProt]
Espionne "$BIdProt $N"
set Access $TabBlast($BIdProt,Access)
lappend LesProteines [list $BIdProt $N $Id $Access]
if {[expr $N < (3*$NMax)/4]} { break }
if {$NMax < $N} {set NMax $N}
}
set NMaxMin [expr $NMax * (1 - $Var)]
if {$LesProteines == {}} {return ""}
set AccessmRNA ""
set TousLesOSs {}
Espionne $Nom
Espionne $LesProteines
foreach LaProteine [lsort -integer -index 1 -decreasing [lsort -real -index 2 -decreasing $LesProteines]] {
Espionne $LaProteine
set N [lindex $LaProteine 1]
if {$N < $NMaxMin} {break}
set BIdProt [lindex $LaProteine 0]
set Access [lindex $LaProteine 3]
Espionne $Access
set LesOSs [LesOrgasDeLAccess $Access]
Espionne $LesOSs
if {$LesOSs!={}} { LConcat TousLesOSs $LesOSs }
}
Espionne $LaProteine
if {$TousLesOSs=={}} { return "" }
set TousLesOSs [lsort -unique $TousLesOSs]
return [join $TousLesOSs ":"]
}
proc OrganismeDuBIdCiteDansNuctfaPourTous {} {
set FichierOrganismesDesPABs "[RepertoireDuGenome]/fiches/organismesdespabs"
if {[file exists $FichierOrganismesDesPABs]} {
foreach Ligne [LesLignesDuFichier $FichierOrganismesDesPABs] {
scan $Ligne "%s" NomLu
set DejaVu($NomLu) 1
}
}
foreach Nom [ListeDesPABs] {
if {[info exists DejaVu($Nom)]} { continue }
set FTfa "[RepertoireDuGenome]/nuctfa/$Nom"
if { ! [file exists $FTfa]} { continue }
scan [EnteteDuFichierTFA $FTfa] "%s %s %s %s %s" NomLu Access mRNA of BId
set Organisme [OrgaDuAccess $Access "Complet" $BId]
Espionne "$Nom $Organisme"
AppendAuFichier $FichierOrganismesDesPABs "$Nom $Organisme"
}
return $FichierOrganismesDesPABs
}
proc OrInformeAvecDaedalusHitPourTousganismeDuPABPourTous {{Source ""}} {
if {$Source=="DaedalusHit" || \
($Source=="" && \
[OuiOuNon "Do I use blastp DaedalusHits to determine the organism ?"])} {
return [InformeAvecDaedalusHitPourTous "OS_OC"]
}
if {$Source=="BIdDuNuctfa" || \
($Source=="" && \
[OuiOuNon "Do I use the BId from nuctfa/[PreFixe]xxxx to determine the organism ?"])} {
return [OrganismeDuBIdCiteDansNuctfaPourTous]
}
if {$Source=="BlastP" || \
($Source=="" && \
[OuiOuNon "Do I search for closest hit in Blastp to determine the organism of each Box?"])} {
return [PlusProcheOrganismeDuBlastPourTous]
}
if {$Source=="Narcisse" || \
($Source=="" && \
[OuiOuNon "Do I use the organism I'll find in Narcisse ?"])} {
return [PlusProcheOrganismeDuNarcissePourTous]
}
return ""
}
proc ScafoldDeCiona S {
return [LaSequenceDuTFAs \
"/genomics/link/Ciona/banques/Ciona_intestinalis" "Ciona_intestinalis_$S" DontMemorize]
}
proc FragmentDuFichierTFA {FichierTFA {Debut ""} {Fin ""} {Comment ""} {FichierSortie ""}} {
set Entete [EnteteDuFichierTFA $FichierTFA]
set Seq [QueLaSequenceDuFichierTFA $FichierTFA]
set Long [string length $Seq]
while {$Debut==""} {
set DF [Entre "1 $Long"]
set Fin ""
scan $DF "%d %d" Debut Fin
if {$Fin==""} { set Debut "" }
}
set D $Debut
set F $Fin
incr D -1
incr F -1
set Frag [string range $Seq $D $F]
regsub { |$} $Entete "-$Debut-$Fin " NouvelleEntete
set TFA [SequenceFormatTFA $Frag "$NouvelleEntete" brut]
if {[string equal -nocase $Comment "sequence"]} { return $Frag }
if {[string equal -nocase $Comment "tfa"]} { return $TFA }
if {[string equal -nocase $Comment "file"]} {
if {$FichierSortie==""} { set FichierSortie [FichierPourSaveAs]}
return [Sauve $TFA dans $FichierSortie]
}
return $TFA
}
proc FromFasta {FichierTFA {FichierGCG ""}} {
if {![file exists $FichierTFA]} { return "" }
set FicGCG "[TmpFile].gcg"
exec clustalw $FichierTFA -convert -output=gcg -outfile=$FicGCG
if {[file exists $FicGCG]} {
file copy -force $FicGCG $FichierGCG
file delete $FicGCG
return FichierGCG
}
FaireLire "FromFasta n'existe plus"
#suite obsolete
set FichierTFATmp "[TmpFile].tfa"
file copy $FichierTFA $FichierTFATmp
exec fromfasta -NUC $FichierTFATmp -LIS
if {![file exists "fromfasta.list"]} {return ""}
foreach Ligne [LesLignesDuFichier "fromfasta.list"] {
if { ! [regexp {Begin:[0-9]} $Ligne]} {continue}
scan $Ligne "%s" FichierGCGCree
}
file delete -force "fromfasta.list"
if {![file exists $FichierGCGCree]} {return ""}
if {$FichierGCG==""} { return $FichierGCGCree }
file copy -force $FichierGCGCree $FichierGCG
return $FichierGCG
}
proc MemesSequencesDansFichiersTFAPourTous {AutreRep {BonRep ""}} {
if {$BonRep==""} { set BonRep "[RepertoireDuGenome]/prottfa" }
foreach Nom [ListeDesPABs] {
set FichierTFA "$BonRep/$Nom"
Espionne "$Nom [MemesSequencesDansFichiersTFA $FichierTFA $AutreRep Pourquoi]"
}
exit
}
proc MemesSequencesDansFichiersTFA {A B {Pourquoi ""}} {
if {$Pourquoi!="" && $Pourquoi!=0} { set Pourquoi 1 } else { set Pourquoi 0 }
if {[file isdirectory $B]} { set B "$B/[file tail $A]" }
if { ! [file exists $A] } {
if {$Pourquoi} { return "0 : file is missing (grey)" }
return 0
}
if { ! [file exists $B] } {
if {$Pourquoi} { return "0 : Query file is missing (white)" }
return 0
}
set SeqA [QueLaSequenceDuFichierTFA $A]
set SeqB [QueLaSequenceDuFichierTFA $B]
set lA [string length $SeqA]
set lB [string length $SeqB]
set Egal [string equal -nocase $SeqA $SeqB]
if { ! $Pourquoi } { return $Egal }
if {$Egal } { return "1 : same sequences (green)" }
if {$lA<$lB && [regexp -nocase $SeqA $SeqB]} { return "0 : Query overlaps (orange)" }
if {$lB<$lA && [regexp -nocase $SeqB $SeqA]} { return "0 : Query is overlaped (yellow)" }
return "0 : the sequences are different (red)"
}
proc InventaireDesAccessDesMSF Repertoire {
set LocalDir [pwd]
cd $Repertoire
set LesMSFs [glob -nocomplain "*.msf"]
foreach Fichier $LesMSFs {
if { ! [DecortiqueUnMSF $Fichier LesAccess Sequences]} { continue }
set Fichier [file tail $Fichier]
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
lappend SesMSFs($ACCESS) $Fichier
if { ! [info exists DejaVu($ACCESS)]} {
lappend TousLesAccess $Access
lappend TousLesACCESS $ACCESS
}
set DejaVu($ACCESS) 1
}
}
foreach Access $TousLesAccess ACCESS $TousLesACCESS {
set LesMSFs [set SesMSFs($ACCESS)]
if {[set N [llength $LesMSFs]] > 1} {
set Texte [format "Vu %2d fois %-20s" $N $Access]
foreach FicMSF $LesMSFs {
append Texte [format "%-18s" $FicMSF]
}
Espionne $Texte
}
}
exit
}
proc MiseAJourDesAccessDuFichierMSF {Fichier {Output ""}} {
Wup "Updates the old access numbers (mainly SPTNEW) with the new one"
Wup " the old access appears in the DBxref field"
Wup "If I detect 2 identical sequences I delete the second one."
if {$Output==""} { set Output "$Fichier.maj" }
if {$Output!="GetLines"} { set FichierSortie $Output }
DecortiqueUnMSF $Fichier LesAccess Sequences
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
set DejaVu($ACCESS) 1
regsub -all {\.} [set Sequences($Access)] "" Sequences($Access)
set Sequences($ACCESS) [set Sequences($Access)]
}
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
Espionne $Access
if { ! [regexp -nocase {^[a-z]{3}[0-9]+$} $Access] } { continue }
set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOk "OnVeutEMBL"]
set Meilleur ""
foreach Ligne $LesLignesEMBL {
if { ! [regexp "^AC " $Ligne]} { continue }
regsub -all {[\;\.]} $Ligne " " Ligne
scan $Ligne "%s %s" Bidon AccessLu
if {[string equal -nocase $Access $AccessLu]} { break }
set Meilleur $AccessLu
}
if {$Meilleur==""} { continue }
set ACCESSLU [string toupper $AccessLu]
Espionne "$Access $Meilleur"
if {[info exists DejaVu($ACCESSLU)]} {
Espionne $ACCESSLU
if {[string equal -nocase [set Sequences($Access)] [set Sequences($ACCESSLU)]]} {
set AJeter($ACCESS) 1
} else {
Espionne "[set Sequences($Access)]\n[set Sequences($ACCESSLU)]"
if { ! [info exists Numero($ACCESSLU)]} {
set Numero($ACCESSLU) 1
}
incr Numero($AccessLu)
set Meilleur "${AccessLu}_[set Numero($AccessLu)]"
}
}
set Meilleurs($ACCESS) $Meilleur
set MEILLEUR [string toupper $Meilleur]
set DejaVu($MEILLEUR) 1
set Sequences($MEILLEUR) [set Sequences($Access)]
}
Espionne [array get AJeter]
Espionne [array get Meilleurs]
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {[a-z0-9_]} $Ligne]} { lappend Sortie $Ligne ; continue }
scan $Ligne "%s %s" AccessOuName Access
if { ! [string equal -nocase $AccessOuName "Name:"]} { set Access $AccessOuName }
set ACCESS [string toupper $Access]
Espionne "Je teste $Access"
if {[info exists AJeter($ACCESS)]} { Espionne "Je jette $Access" ; continue }
if {[info exists Meilleurs($ACCESS)]} {
set Meilleur [set Meilleurs($ACCESS)]
set M [expr [Maxi [string length $Meilleur] [string length $Access]] - 1]
set Old [string range "$Access " 0 $M]
set New [string range "$Meilleur " 0 $M]
regsub $Old $Ligne $New Ligne
}
lappend Sortie $Ligne
}
if {$Output=="GetLines"} { return $Sortie }
return [SauveLesLignes $Sortie dans $FichierSortie]
}
proc TestUnixFileName {} {
foreach Ligne [LesLignesDuFichier "[HomeRipp]/lesbanquestblastn"] {
scan $Ligne "%s" Banque
Espionne "$Banque [UnixFileName $Banque]"
}
exit
}
proc UnixFileName Banque {
global DirectoryNames DirLogNames CompleteFileNames
if {[info exists DirectoryNames]} {
if {[info exists CompleteFileNames([string toupper $Banque])]} {
return [set CompleteFileNames([string toupper $Banque])]
} else {
return $Banque
}
}
set OnAttendPP 1
foreach Ligne [LesLignesDuFichier "/gcg/gcg/gcgdbconfigure/dblogicals"] {
if {$OnAttendPP && ! [regexp {\.\. *$} $Ligne]} { continue }
if {$OnAttendPP && [regexp {\.\. *$} $Ligne]} { set OnAttendPP 0 ; continue }
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s %s" DirLogName Directory
set DirectoryNames([string toupper $DirLogName]) $Directory
set DirLogNames([string toupper $Directory]) $DirLogName
}
set OnAttendPP 1
foreach Ligne [LesLignesDuFichier "/gcg/gcg/gcgdbconfigure/dbnames.map"] {
if {$OnAttendPP && ! [regexp {\.\. *$} $Ligne]} { continue }
if {$OnAttendPP && [regexp {\.\. *$} $Ligne]} { set OnAttendPP 0 ; continue }
if { [regexp -nocase { *\!} $Ligne]} { continue }
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s %s %s %s" FlatFileName DirLogName LibLogName ShortLogName
set Directory [set DirectoryNames([string toupper $DirLogName])]
foreach Ext [list gbk dat seq ""] {
set CompleteFileName "$Directory/$FlatFileName.$Ext"
if {[file exists $CompleteFileName]} { break }
}
set CompleteFileNames([string toupper $ShortLogName]) $CompleteFileName
}
return [UnixFileName $Banque]
}
proc NonOverlapingSeqADN {SeqADN {Reset ""}} {
global OldNonOverlapingSeqADN
set SeqADN [string toupper $SeqADN]
if {$Reset=="" && [info exists OldNonOverlapingSeqADN]} {
set lAmorce 55
set iOver -1
while { $iOver == -1 && $lAmorce >0 } {
set Amorce [string range $SeqADN 0 [incr lAmorce -1]]
set iOver [string last $Amorce $OldNonOverlapingSeqADN]
}
if {$iOver!=-1} {
set Overlap [string range $OldNonOverlapingSeqADN $iOver end]
} else {
set Overlap ""
}
set lOver [string length $Overlap]
set nAvant [expr 70-$lOver]
Espionne "[string range $OldNonOverlapingSeqADN end-70 end]<"
Espionne "[string repeat " " $nAvant] $Overlap"
Espionne [string range "[string repeat " " $nAvant]>[string range $SeqADN 0 70]" 0 100]
set BonneSeqADN [string range $SeqADN $lOver end]
} else {
set BonneSeqADN $SeqADN
}
set OldNonOverlapingSeqADN $BonneSeqADN
return $BonneSeqADN
}
proc SequenceADNDesFichiersGenBank {{Rep ""}} {
global RepertoireDuGenome
set OldSeqADN ""
if {$Rep==""} {
set Rep "[RepertoireDuGenome]/De*"
set LesReps [glob -type d $Rep]
if {[llength $LesReps]!=1} {
FaireLire "I cannot decide for directory. Please browse for it."
set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[RepertoireDuGenome]"]
if {$Rep==""} { return "" }
} else {
set Rep [lindex $LesReps 0]
}
}
set LesFichiers [lsort [glob "$Rep/*_*"]]
if { ! [OuiOuNon "Ok to use \n\
[lindex $LesFichiers 0] \n\
...\n\
[lindex $LesFichiers end]\n\
?"]} { return "" }
set ADN ""
foreach Fichier $LesFichiers {
DecortiqueGenBank OS OC SeqADN $Fichier
set SeqADN [NonOverlapingSeqADN $SeqADN]
append ADN $SeqADN
}
set TFA [SequenceFormatTFA $ADN "adn_corrige" "brut"]
Sauve $TFA dans "[RepertoireDuGenome]/beton/correct.tfa"
exit
}
proc TestLSDT {} {
foreach Access [LaSequenceDuTFAs toto.tfa "LaListeDesAccess"] {
set Seq [LaSequenceDuTFAs toto.tfa $Access]
Espionne " .................$Access\n[SequenceFormatTFA $Seq]"
}
exit
}
proc TestQueLePremierGCG {} {
set GCG [ContenuDuFichier p12345.swissprot]
Espionne [QueLePremierGCG "$GCG\n$GCG"]
exit
}
proc QueLePremierGCG Texte {
scan $Texte "%s" PremierMot
set Prochain "\n$PremierMot"
set iProchain [string first $Prochain $Texte]
if {$iProchain<0} { return $Texte }
return [string range $Texte 0 [incr iProchain -1]]
}
proc TFAToComplementTFA {TFA {Entete ""}} {
#biotcl seq::TFAToComplementTFA {TFA header}
if {$Entete==""} {
set OldEntete [EnteteDuTexteTFA $TFA All]
regsub ">" $OldEntete ">Com_" $Entete
}
set Seq [QueLaSequenceDuTexteTFA $TFA]
set Com [NucToComplementNuc $Seq]
set NewTFA [SequenceFormatTFA $Com $Entete "brut"]
return $NewTFA
}
proc TFAToReverseTFA {TFA {Entete ""}} {
#biotcl seq::TFAToReverseTFA {TFA header}
if {$Entete==""} {
set OldEntete [EnteteDuTexteTFA $TFA All]
regsub ">" $OldEntete ">Rev_" $Entete
}
set Seq [QueLaSequenceDuTexteTFA $TFA]
set Rev [NucToReverseNuc $Seq]
set NewTFA [SequenceFormatTFA $Rev $Entete "brut"]
return $NewTFA
}
proc TFAToReverseAndComplementTFA {TFA {Entete ""}} {
#biotcl seq::TFAToReverseTFA {TFA header}
if {$Entete==""} {
set OldEntete [EnteteDuTexteTFA $TFA All]
regsub ">" $OldEntete ">RevAndCom_" $Entete
}
set Seq [QueLaSequenceDuTexteTFA $TFA]
set RevCom [NucToReverseAndComplementNuc $Seq]
set NewTFA [SequenceFormatTFA $RevCom $Entete "brut"]
return $NewTFA
}
proc NucToReverseAndComplementNuc Seq {
#biotcl seq::nucToReverseAndComplementNuc {seq}
set Rev [NucToReverseNuc $Seq]
set Com [NucToComplementNuc $Rev]
return $Com
}
proc NucToComplementNuc Seq {
#biotcl seq::nucToComplementNuc {seq}
set ListKeyValue [ComplementNuc "ListKeyValue"]
set Com [string map $ListKeyValue $Seq]
return $Com
# set Com ""
# foreach B [split $Seq ""] {
# append Com [ComplementNuc $B]
# }
# return $Com
}
proc NucToReverseNuc Seq {
#biotcl seq::nucToReverseNuc {seq}
return [string reverse $Seq]
# set Rev ""
# for {set i [expr [string length $Seq]-1]} {$i>=0} {incr i -1} {
# append Rev [string index $Seq $i]
# }
# return $Rev
}
proc PossibleNucleotides {} {
#biotcl possibleNucleotides {}
return [ComplementNuc "ListKey"]
}
proc ComplementNuc Nuc {
#biotcl complementNuc {nuc}
global ComplementNuc
if {[info exists ComplementNuc($Nuc)]} { return [set ComplementNuc($Nuc)] }
if {[info exists ComplementNuc]} { return $Nuc }
set ComplementNuc(X) "X"
set ComplementNuc(x) "x"
set ComplementNuc(A) "T"
set ComplementNuc(T) "A"
set ComplementNuc(G) "C"
set ComplementNuc(C) "G"
set ComplementNuc(a) "t"
set ComplementNuc(t) "a"
set ComplementNuc(g) "c"
set ComplementNuc(c) "g"
set ComplementNuc(N) "N"
set ComplementNuc(n) "n"
set ComplementNuc(M) "K"
set ComplementNuc(K) "M"
set ComplementNuc(R) "Y"
set ComplementNuc(Y) "R"
set ComplementNuc(W) "W"
set ComplementNuc(S) "S"
set ComplementNuc(m) "k"
set ComplementNuc(k) "m"
set ComplementNuc(r) "y"
set ComplementNuc(y) "r"
set ComplementNuc(w) "w"
set ComplementNuc(s) "s"
set ComplementNuc(V) "B"
set ComplementNuc(H) "D"
set ComplementNuc(D) "H"
set ComplementNuc(B) "V"
set ComplementNuc(v) "b"
set ComplementNuc(h) "d"
set ComplementNuc(d) "h"
set ComplementNuc(b) "v"
set ComplementNuc(ListKey) [array names ComplementNuc]
set ComplementNuc(ListKeyValue) [array get ComplementNuc]
return [ComplementNuc $Nuc]
}
proc Transcript {Bornes aSeqADN} {
upvar $aSeqADN SeqADN
Wup "create the mRAN from the DNA ... I will soon use join and complement etc."
scan $Bornes "%d %d %s" Debut Fin Orient
incr Debut -1
incr Fin -1
set Seq [string range $SeqADN $Debut $Fin]
if {$Orient=="F"} {
return $Seq
} else {
return [NucToReverseAndComplementNuc $Seq]
}
}
proc TestEE {} {
set Meilleur [lindex [LesAccessEMBLDesLignesEMBL [LaSequenceDesBanques syd_ecoli syd_ecoli AccessOK "OnVeutEMBL"]] 2]
set LeGenBank [LaSequenceDesBanques $Meilleur $Meilleur AccessOK "OnVeutNature"]
EspionneL [DecortiqueGenBank OS OC SeqADN $LeGenBank]
exit
}
proc LesAccessEMBLDesLignesEMBL LesLignes {
set LesMots {}
foreach Ligne [LeChampDesLignesEMBL $LesLignes "DR"] {
if { ! [regexp "DR EMBL" $Ligne]} { continue }
regsub "DR EMBL" $Ligne "" Ligne
regsub -nocase -all {[^a-z_0-9\.]} $Ligne " " Ligne
set LesMots [concat $LesMots [split $Ligne " "]]
}
set LesBons {}
foreach Mot $LesMots {
if { ! [regexp -nocase {[a-z]} $Mot]} { continue }
if {[regexp "NOT_ANNOTATED_CDS" $Mot]} { continue }
lappend LesBons $Mot
}
return $LesBons
}
proc LeChampDesLignesEMBL {LesLignes Champ} {
set Sortie {}
foreach Ligne $LesLignes {
if {[regexp "^$Champ" $Ligne]} { lappend Sortie $Ligne }
}
return $Sortie
}
proc Locus {Texte FichierTFA} {
set Seq "x[QueLaSequenceDuTFA $FichierTFA]"
set iStart 1
while {[regexp -indices -start $iStart -nocase -- $Texte $Seq LesIndices]} {
Espionne $LesIndices
set iStart [lindex $LesIndices 1]
}
exit
}
proc ZoneADN {Debut Fin FicTexCon {Orient ""}} {
Wup "Chooses between Texte Fichier and Contig. Use the correct if you know it"
if {[regexp {[> \n\t]} $FicTexCon]} { return [ZoneADNDuTexteTFA $Debut $Fin $FicTexCon $Orient] }
if {[regexp "/" $FicTexCon]} { return [ZoneADNDuFichierTFA $Debut $Fin $FicTexCon $Orient] }
if {[file exists $FicTexCon]} { return [ZoneADNDuFichierTFA $Debut $Fin $FicTexCon $Orient] }
if {[regexp -nocase {[A-Z0-9]+(\:|_)[A-Z0-9]+} $FicTexCon]} {
set EssaiContig [ZoneADNDuContig $Debut $Fin $FicTexCon $Orient]
if {$EssaiContig!=""} { return $EssaiContig }
}
return [ZoneADNDuTexteTFA $Debut $Fin $FicTexCon $Orient]
}
proc ZoneADNDuContig {Debut Fin ChroContig {Orient ""}} {
set FichierTFA [ContigEnStock $ChroContig "FileNamePlease"]
if {$FichierTFA==""} { return "" }
return [ZoneADNDuFichierTFA $Debut $Fin $FichierTFA $Orient]
}
proc ZoneADNDuFichierTFA {Debut Fin FichierTFA {Orient ""}} {
if {$FichierTFA=="" || ! [file exists $FichierTFA]} { return "" }
return [ZoneADNDuTexteTFA $Debut $Fin [ContenuDuFichier $FichierTFA] $Orient]
}
proc ZoneADNDuTexteTFA {Debut Fin Texte {Orient ""}} {
Wup "if Orient (F or R, + or -) exists it decides for the orientation, otherwize I test Fin < Debut"
Wup "Returns a contigous DNA zone from Debut to Fin (reverse and complement if Orient - )"
Wup "Count start with 1 not 0"
set Seq "x[QueLaSequenceDuTexteTFA $Texte]"
if {$Fin=="end"} { set Fin [string length $Seq] }
set D [Maxi 1 [Mini $Debut $Fin]]
set F [Maxi $Debut $Fin]
set Zone [string range $Seq $D $F]
if {[regexp -nocase {F|\+} $Orient]} { set Positif 1 }
if {[regexp -nocase {R|\-} $Orient]} { set Positif 0 }
if { $Orient=="" && $Debut<=$Fin } { set Positif 1 }
if { $Orient=="" && $Fin <$Debut } { set Positif 0 }
if {$Positif} {
return $Zone
} else {
return [NucToReverseAndComplementNuc $Zone]
}
}
proc TestFusionneLesGenscan {A B TailleTroncon} {
set LeGscA [LesLignesDuFichier $A]
set LeGscB [LesLignesDuFichier $B]
EspionneL [FusionneLesGenscan $LeGscA $LeGscB $TailleTroncon]
exit
}
proc FusionneLesGenscan {LeGscA LeGscB TailleTroncon} {
set Offset $TailleTroncon
set Coupure [DernierPointDeCoupure $LeGscA $LeGscB $TailleTroncon]
Espionne $Coupure
if {$Coupure==-1} {
set A [lindex $LeGscA 0]
set B [lindex $LeGscB 0]
FaireLire "I cannot merge these two GenScan outputs\n $A \ $B"
return ""
}
set OldP ""
foreach Ligne $LeGscA {
if {[regexp "^Sequence" $Ligne]} {
scan $Ligne "%s %s" S Access
set Ligne "$S $Access Genscan outputs from overlapping contigs merged by Gscope after $Coupure"
lappend Sortie $Ligne
continue
}
if { ! [regexp {^ *[0-9]+\.[0-9]+} $Ligne]} {
lappend Sortie $Ligne
continue
}
scan $Ligne "%s %s %s %d %d" PE Type Sens D F
if {$D >= $Coupure} { break }
scan [split $PE "."] "%d %d" P E
if {$OldP!=$P} { lappend LesPremiersPs $P }
set OldP $P
set DernierP $P
lappend Sortie $Ligne
}
set OnAttend 1
set NouveauP $DernierP
set OldP ""
foreach Ligne $LeGscB {
if { $OnAttend && ! [regexp {^ *[0-9]+\.[0-9]+} $Ligne]} {
continue
}
if {[regexp "Predicted peptide" $Ligne]} {
lappend Sortie $Ligne
lappend Sortie " "
break
}
if { ! [regexp {^ *[0-9]+\.[0-9]+} $Ligne]} {
lappend Sortie $Ligne
continue
}
scan $Ligne "%s %s %s %d %d" PE Type Sens D F
set NouveauD [expr $D + $Offset]
set NouveauF [expr $F + $Offset]
if {$NouveauD<$Coupure} { continue }
set OnAttend 0
scan [split $PE "."] "%d %d" P E
if {$P!=$OldP} {
incr NouveauP
lappend LesSecondsPs $P
lappend LesNouveauxPs $NouveauP
}
regsub $P $Ligne $NouveauP Ligne
set OldP $P
regsub " $D " $Ligne " $NouveauD " Ligne
regsub " $F " $Ligne " $NouveauF " Ligne
lappend Sortie $Ligne
}
DecortiqueGenScan All All Numbers [join $LeGscA "\n"]
foreach P $LesPremiersPs {
set Texte [DecortiqueGenScan $P All "TFAo"]
lappend Sortie $Texte
lappend Sortie " "
}
DecortiqueGenScan All All Numbers [join $LeGscB "\n"]
foreach P $LesSecondsPs N $LesNouveauxPs {
set Texte [DecortiqueGenScan $P All "TFAo"]
regsub "predicted_peptide_$P" $Texte "predicted_peptide_$N" Texte
lappend Sortie $Texte
lappend Sortie " "
}
return $Sortie
}
proc SizeOfFilesIn {A B} {
foreach FA [glob -nocomplain "$A/*"] {
set sA [file size $FA]
set Q [file tail $FA]
set FB "$B/$Q"
if {[file exists $FB]} { set sB [file size $FB] } else { set sB -1 }
lappend Sortie [format "%20d %10d %s" $sA $sB $Q]
}
set Sortie [lsort -command CompareLesIntegersEnDebut $Sortie]
EspionneL $Sortie
exit
}
proc DernierPointDeCoupure {LeGscA LeGscB TailleTroncon} {
set Marge ""
set Offset 0
foreach X {"LeGscA" "LeGscB"} {
foreach Ligne [set $X] {
if { ! [regexp {^ *[0-9]+\.[0-9]+} $Ligne]} { continue }
scan $Ligne "%s %s %s %d %d" PE Type Sens D F
incr D $Offset
incr F $Offset
lappend LesDebuts $D
lappend LesTouches($D) "$Marge $PE $Type $Sens $D $F"
set MargeBlanche($D) [string repeat " " [string length "$Marge $PE $Type $Sens $D $F"]]
}
set Marge " === "
set Offset $TailleTroncon
}
set LesDebutsTries [lsort -unique -integer $LesDebuts]
set GeneComplet 0
set GeneDebute 0
set OldGeneComplet 0
set DernierPointDeCoupure -1
set DernierPointEgalite -1
set DernierValide 0
set ProchainValide 0
set AvantDernierDebut -1
set DernierDebut -1
foreach D $LesDebutsTries {
set L [join $LesTouches($D) ""]
regsub "^ === " $L $MargeBlanche($D) L
Espionne $L
set GeneDebute 0
if {[regexp "===" $L]} { set DernierPointEgalite $D }
if {[regexp "===" $L] || [regexp { [0-9]+} $L]} {
set GeneDebute [expr [regexp {Prom \+} $L] || [regexp {PlyA \-} $L]]
set GeneComplet [expr [regexp "===" $L] && ([regexp {PlyA \+} $L] || [regexp {Prom \-} $L])]
if {$GeneComplet} { set ProchainValide 1 ; continue }
}
if {$GeneDebute} { set AvantDernierDebut $DernierDebut ; set DernierDebut $D }
if {$ProchainValide && $GeneDebute} { return $D }
if {$GeneComplet && $GeneDebute} {
set GeneComplet 0
set GeneDebute 0
set AvantDernierPointDeCoupure $DernierPointDeCoupure
set DernierPointDeCoupure $D
set DernierValide 0
}
if { ! [regexp { [0-9]+} $L]} {
set DernierValide 1
set GeneComplet [expr [regexp {PlyA \+} $L] || [regexp {Prom \-} $L]]
}
}
if { $DernierPointDeCoupure == -1} {
if {$DernierPointEgalite!=-1} { return $DernierPointEgalite }
if { $AvantDernierDebut !=-1} { return $AvantDernierDebut }
if { $DernierDebut !=-1} { return $DernierDebut }
}
if { $DernierValide } {
return $DernierPointDeCoupure
} else {
return $AvantDernierPointDeCoupure
}
}
proc TestInfoEmbl {} {
set Access "P12345"
Espionne [InfoEmbl $Access SQ]
Espionne [InfoEmbl $Access Delete]
exit
}
#rR attention il existe aussi une procedure EmblInfo
proc InfoEmbl {{Qui ""} {Quoi ""}} {
global InfoEmbl
if {$Quoi=="Delete"} {
if { ! [info exists InfoEmbl($Qui,EstCharge)]} { return 0 }
set N 0
foreach QQ $InfoEmbl($Qui,Data) {
incr N
unset InfoEmbl($QQ)
}
return $N
}
if {[info exists InfoEmbl($Qui,$Quoi)]} { return $InfoEmbl($Qui,$Quoi) }
if {[info exists InfoEmbl($Qui,EstCharge)]} { return "" }
set InfoEmbl($Qui,EstCharge) ""
set LesLignesEmbl [LaSequenceDesBanques $Qui $Qui AccessOk "OnVeutEMBL"]
if {$LesLignesEmbl=={}} { return "" }
set Embl [join $LesLignesEmbl "\n"]
set InfoEmbl($Qui,Embl) $Embl
set InfoEmbl($Qui,AccessOk) $AccessOk
set AllInfo [DecortiqueLesLignesEMBL $LesLignesEmbl ID AC DE GN OS OC OX SQ]
foreach {K V} $AllInfo {
set InfoEmbl($Qui,Info$K) $V
}
set SQ [string toupper $SQ]
set InfoEmbl($Qui,ID) $ID
set InfoEmbl($Qui,AC) $AC
set InfoEmbl($Qui,DE) $DE
set InfoEmbl($Qui,GN) $GN
set InfoEmbl($Qui,OS) $OS
set InfoEmbl($Qui,OC) $OC
set InfoEmbl($Qui,OX) $OX
set InfoEmbl($Qui,SQ) $SQ
set InfoEmbl($Qui,Length) [string length $SQ]
foreach A [split $SQ ""] {
incr InfoEmbl($Qui,n$A)
lappend InfoEmbl($Qui,ListOfAA) $A
}
set InfoEmbl($Qui,ListOfAA) [lsort -unique $InfoEmbl($Qui,ListOfAA)]
set AllP {}
foreach A $InfoEmbl($Qui,ListOfAA) {
set InfoEmbl($Qui,p$A) [expr (100.*$InfoEmbl($Qui,n$A))/$InfoEmbl($Qui,Length)]
lappend AllP "$A [format %4.1f $InfoEmbl($Qui,p$A)]"
}
set InfoEmbl($Qui,AllP) $AllP
set InfoEmbl($Qui,AllPSort) [lsort -decreasing -index 1 -real $AllP]
foreach QQ [array names InfoEmbl] {
if {[regexp "^$Qui\," $QQ]} { lappend InfoEmbl($Qui,Data) $QQ }
}
return [InfoEmbl $Qui $Quoi]
}
#rR attention il existe aussi une procedure InfoEmbl
proc EmblInfo {AccessOuTexteOuLesLignesEMBL {K ""} {GetWhat ""}} {
if {[regexp "\n" $AccessOuTexteOuLesLignesEMBL]} {
set LesLignesEMBL [split $AccessOuTexteOuLesLignesEMBL "\n"]
} elseif {[regexp " " $AccessOuTexteOuLesLignesEMBL]} {
set LesLignesEMBL AccessOuTexteLesLignesEMBL
} else {
set Access $AccessOuTexteOuLesLignesEMBL
set LesLignesEMBL [LaSequenceDesBanques $Access]
}
if {$LesLignesEMBL==""} { return "" }
if {$GetWhat==""} { set GetWhat "GetList" }
set ListOfInfo [DecortiqueLesLignesEMBL $LesLignesEMBL]
if {$K==""} { return $ListOfInfo }
array set AllInfo $ListOfInfo
if { ! [info exists AllInfo($K)]} { return "" }
if {$GetWhat=="GetText"} { return [join $AllInfo($K) " "] }
return $AllInfo($K)
}
proc TestDecortiqueEMBL {{Fichier ""}} {
if {$Fichier==""} { set Fichier "./essai.embl" }
set LL [LaSequenceDesBanques $Fichier]
DecortiqueLesLignesEMBL $LL ID AC DE GN OS OC OX SequenceBrute LaDETotal
EspionneL [list $ID $AC $DE $GN $OS $OC $OX $LaDETotal]
Espionne $SequenceBrute
exit
}
proc DecortiqueLesLignesEMBL {LesLignesEMBL {aID ""} {aAC ""} {aDE ""} {aGN ""} {aOS ""} {aOC ""} {aOX ""} {aSequenceBrute ""} {aLaDETotal ""} {aGNTotal ""}} {
#rR pour avoir toutes les infos voir la procedure EmblInfo ou aussi InfoEmbl
if {$aID!=""} { upvar $aID ID }
if {$aAC!=""} { upvar $aAC AC }
if {$aDE!=""} { upvar $aDE DE }
if {$aGN!=""} { upvar $aGN GN }
if {$aOS!=""} { upvar $aOS OS }
if {$aOC!=""} { upvar $aOC OC }
if {$aOX!=""} { upvar $aOX OX }
if {$aSequenceBrute != ""} {
upvar $aSequenceBrute SequenceBrute
set AvecSequence 1
} else {
set AvecSequence 0
}
if {$aLaDETotal!=""} { upvar $aLaDETotal LaDETotal }
if {$aGNTotal !=""} { upvar $aGNTotal GNTotal }
set SansOs 1
set StringOC ""
set SansDE 1
set ID ""
set AC ""
set OS "Genre espece"
set OC ""
set OX ""
set LaDETotal {}
set DE ""
set RecNameDejaVu 0
set RecNameEnCours 0
set SubNameDejaVu 0
set SubNameEnCours 0
set DEFull ""
set DEShort ""
set DEEC ""
set GN ""
set GNTotal ""
set LaSeq {}
set YaSQ 0
set CurRN 0 ; #rR pour les numeros de review
foreach Ligne $LesLignesEMBL {
if {[regexp "^//" $Ligne]} { break }
set CurK "SEQUENCE"
set K ""
if {[regexp {^([A-Z][A-Z]) } $Ligne Match K]} {set CurK $K}
set Information [string range $Ligne 5 end]
regexp {RN \[([0-9]+)\]} $Ligne Match CurRN
if {[regexp {^R} $K]} {
lappend AllInfo(R$CurRN) "$K $Information"
} else {
lappend AllInfo($K) $Information
}
set Information [string trim $Information]
if {[regexp "^SQ " $Ligne]} { set YaSQ 1 ; continue }
if {$YaSQ} { lappend LaSeq $Ligne }
if {$ID=="" && [regexp "^ID " $Ligne]} { scan $Information "%s" ID ; regsub {\;.*} $ID "" ID }
if {$AC=="" && [regexp "^AC " $Ligne]} { scan $Information "%s" AC ; regsub {\;.*} $AC "" AC }
if { $SansOs && [regexp "^OS" $Ligne] } {
set lili [split $Information " "]
set Genre [lindex $lili 0]
regsub {[^A-Za-z]} [lindex $lili 1] "" Espece
#rR A la demande de lM on ne passe plus par glossaire !!!!!!!!!!!!!!!!!!!!!!!!!!!!
set OS "$Genre $Espece"
#rR set OS [Glossaire "$Genre $Espece" Complet]
#rR if {$OS==""} { set OS "$Genre $Espece" }
set SansOs 0
}
if [regexp "^OC " $Ligne] {
append OC "$Information "
}
if [regexp "^OX " $Ligne] {
append OX "$Information "
}
if [regexp "^DE " $Ligne] {
lappend LaDETotal $Information
if {$RecNameEnCours && [regexp {^Short=} $Information]} {
set DEShort [StringApres "=" dans $Information]
set DEShort "Short:$DEShort"
set DEShort [string trim $DEShort " ;,"]
continue
}
if {$RecNameEnCours && [regexp {^EC=} $Information]} {
set DEEC [StringApres "=" dans $Information]
set DEEC "EC:$DEEC"
set DEEC [string trim $DEEC " ;,"]
continue
}
if { ! $RecNameDejaVu} {
if {[regexp {RecName: Full=} $Information]} {
set DEFull [string trim [StringSuivant "=" dans $Information] " ;,"]
set RecNameEnCours 1
set RecNameDejaVu 1
continue
}
}
set RecNameEnCours 0
if { ! $RecNameDejaVu && $SubNameEnCours && [regexp {^Short=} $Information]} {
set DEShort [StringApres "=" dans $Information]
set DEShort "Short:$DEShort"
set DEShort [string trim $DEShort " ;,"]
continue
}
if { ! $RecNameDejaVu && $SubNameEnCours && [regexp {^EC=} $Information]} {
set DEEC [StringApres "=" dans $Information]
set DEEC "EC:$DEEC"
set DEEC [string trim $DEEC " ;,"]
continue
}
if { ! $RecNameDejaVu && ! $SubNameDejaVu} {
if {[regexp {SubName: Full=} $Information]} {
set DEFull [string trim [StringSuivant "=" dans $Information] " ;,"]
set SubNameEnCours 1
set SubNameDejaVu 1
continue
}
}
set SubNameEnCours 0
}
if {[regexp "^GN " $Ligne]} {
if {$GN==""} {
set GN $Information
set GNTotal $Information
if {[regexp "Name=" $GN]} {
set GN [StringApres "=" dans $GN]
set GN [string trim $GN " ;,"]
}
} else {
append GNTotal " $Information"
}
}
}
set DE [join $LaDETotal " / "]
if {$DEFull!=""} { set DE "$DEFull $DEShort $DEEC" }
#rR attention depuis 20150405 je ne prends que le premier nombre car il y a d'autres m....s derrière
regsub -all {[^0-9]} $OX " " OX
set OX [string trim $OX]
regsub -all { .+$} $OX "" OX
set SequenceBrute [join $LaSeq ""]
regsub -all {[ 0-9\t\n\.\*/]} $SequenceBrute "" SequenceBrute
set AllInfo(RN) $CurRN
return [array get AllInfo]
}
proc TestReassembleLesTronconsGenscan {Contig TailleTroncon} {
set LesTroncons [lsort [glob -nocomplain "toto*.gsc"]]
Espionne [ReassembleLesTronconsGenscan $LesTroncons $TailleTroncon "fusion.gsc"]
exit
}
proc ReassembleLesTronconsGenscan {LesTronconsGSC TailleTroncon {FichierGSC ""}} {
if {$FichierGSC==""} {
set RetourneLeTexte 1
} else {
set RetourneLeTexte 0
}
set Offset 0
if {[llength $LesTronconsGSC]==0} { return {}}
set FichierGscA [lindex $LesTronconsGSC 0]
if {[llength $LesTronconsGSC]==1} {
if {$RetourneLeTexte} {
return [ContenuDuFichier $FichierGscA]
} else {
return [File copy $FichierGscA $FichierGSC]
}
}
set LeGscA [LesLignesDuFichier $FichierGscA]
set Offset 0
foreach FichierGscB [lrange $LesTronconsGSC 1 end] {
Espionne $FichierGscB
incr Offset $TailleTroncon
set LeGscB [LesLignesDuFichier $FichierGscB]
set LeGscA [FusionneLesGenscan $LeGscA $LeGscB $Offset]
}
if {$RetourneLeTexte} {
return [join $LeGscA "\n"]
} else {
return [SauveLesLignes $LeGscA dans $FichierGSC]
}
}
proc TronconneLeFichierTFA {FichierTFA {TailleTroncon 100000} {TailleOverlap 10000} {Working "UseSameNameOnTmp"}} {
Wup "Cuts the tfa file into fragments"
if {$Working=="UseSameNameOnTmp"} {
set Queue [file tail $FichierTFA]
regsub ".tfa$" $Queue "" Queue
set WD "[RepertoireDeTravail]"
}
if {$Working=="UseSameName"} {
set Queue [file tail $FichierTFA]
regsub ".tfa$" $Queue "" Queue
set WD [file dirname $FichierTFA]
}
if {$Working=="UseTmpFile"} {
set Tmp [TmpFile]
set Queue [file tail $Tmp]
set WD [file dirname $Tmp]
}
set LesTroncons {}
set iFinTroncon [expr $TailleTroncon + $TailleOverlap -1]
set TFA [ContenuDuFichier $FichierTFA]
set Entete [PremiereLigneDuFichier $FichierTFA]
scan $Entete "%s" ChevronAccess
set Seq [QueLaSequenceDuTFA $FichierTFA]
set PasLaPeine [expr [string length $Seq] < $TailleTroncon]
set N 1
set D 1
while {$Seq!=""} {
set Troncon [string range $Seq 0 $iFinTroncon]
set F [expr $D+[string length $Troncon]-1]
if {$PasLaPeine} {
set BeauN ""
set FromBase ""
} else {
set BeauN "_[format "%2.2d" $N]"
set FromBase "from base $D to $F "
}
set FichierSortie "$WD/${Queue}${BeauN}.tfa"
regsub "$ChevronAccess " $Entete "$ChevronAccess $FromBase" NouvelleEntete
regsub "^>" $NouvelleEntete "" NouvelleEntete
Sauve [SequenceFormatTFA $Troncon $NouvelleEntete "brut"] dans $FichierSortie
lappend LesTroncons $FichierSortie
if {[string length $Seq] <= $iFinTroncon} { break }
set Seq [string range $Seq $TailleTroncon end]
incr D $TailleTroncon
incr N
}
return $LesTroncons
}
proc GenScanEnStock {Access {GSC ""}} {
global RepertoireDuGenome
set RetourFileNamePlease 0
if {[regexp -nocase "^FileNamePlease" $GSC]} {
set RetourFileNamePlease 1
set GSC ""
}
set Access [AccessDuContigDuFragment $Access]
regsub {\:} $Access "_" Access
set Access [string toupper $Access]
set Stock "[RepertoireDuGenome]/stockgenscan"
while { ! [file exists $Stock]} {
if {[OuiOuNon "$Stock doesn't exist.\nDo I link to an existing directory ?"]} {
set Ancien [tk_chooseDirectory -mustexist 1 -initialdir "[RepertoireDuGenome]/.."]
if {$Ancien==""} { continue }
exec ln -s $Ancien $Stock
continue
}
if {[OuiOuNon "$Stock doesn't exist.\nDo I create directory ?"]} {
File mkdir $Stock
continue
}
}
set Fichier "$Stock/$Access"
if {$GSC==""} {
if {[file exists $Fichier]} {
if {$RetourFileNamePlease} {
return $Fichier
} else {
return [ContenuDuFichier $Fichier]
}
return ""
}
} else {
if { ! [regexp -nocase "^GENSCAN" $GSC] && \
! [OuiOuNon "This text :\n\
[string range $GSC 0 100]\n...\n\
doesn't look like a GenScan text.\n\
Are You sure to want to store it in $Fichier ?" 0]} { return "" }
return [Sauve $GSC dans $Fichier]
}
}
proc LesProteinesPreditesDuGenscan {AccessOuFichierGSC {Quoi "TFA"} {Offset 0}} {
global RepertoireDuGenome
Wup "return the list of localisation (if Quoi=Loc) or the tfas file (if =TFA)"
if {[regexp "/" $AccessOuFichierGSC]} {
set TexteGS [ContenuDuFichier $AccessOuFichierGSC]
} else {
set TexteGS [GenScanEnStock $AccessOuFichierGSC]
}
if {$TexteGS==""} {
return {}
}
foreach Prot [DecortiqueGenScan All All Numbers $TexteGS] {
set G [expr [DecortiqueGenScan $Prot All Gauche] + $Offset]
set D [expr [DecortiqueGenScan $Prot All Droite] + $Offset]
set S [DecortiqueGenScan $Prot All Sens]
if {$Quoi=="Loc"} { lappend Sortie "$G $D $S $Prot" }
if {$Quoi=="TFA"} { lappend Sortie [DecortiqueGenScan $Prot All TFAo] }
}
return $Sortie
}
proc GenScanEnStockPourTous {{Contig ""}} {
global RepertoireDuGenome
if {$Contig==""} {
set Liste [glob "$RepertoireDuGenome/stockcontigs/*"]
} else {
set Liste [list "$RepertoireDuGenome/stockcontigs/$Contig"]
}
foreach FichierTFA $Liste {
set Contig [file tail $FichierTFA]
set FichierGSC "$RepertoireDuGenome/stockgenscan/$Contig"
if {[file exists $FichierGSC]} { continue }
Espionne [GenScan $FichierTFA $FichierGSC]
}
}
proc PIetPSdansMSF {FichierMSF A B} {
global RepertoireDuGenome
global MatriceDeSimilarite
global NotreOS
global NotreOrga
if { ! [info exists MatriceDeSimilarite] } {
set OnAttendPP 1
set FichierSimilariteDefaut "[GscopeEtc]/gscope_similarite"
set FichierSimilarite "[RepertoireDuGenome]/fiches/similarite"
if { ! [file exists $FichierSimilarite]} {
set FichierSimilarite $FichierSimilariteDefaut
}
set Entete [PremiereLigneDuFichier $FichierSimilarite]
foreach Ligne [LesLignesDuFichier $FichierSimilarite] {
if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
if {[regexp {\.\.} $Ligne]} {
regsub {\.\.} $Ligne "" Ligne
while {[regexp " " $Ligne ]} { regsub -all " " $Ligne " " Ligne }
set LesAAs [split [string trim $Ligne] " "]
set LesAAsRestants $LesAAs
set OnAttendPP 0
continue
}
if {$OnAttendPP} { continue }
set Ligne [string toupper $Ligne]]
set AACourant [lindex $LesAAsRestants 0]
while {[regexp " " $Ligne ]} { regsub -all " " $Ligne " " Ligne }
set nRestants [llength $LesAAsRestants]
set LesScores [lrange [split [string trim $Ligne] " "] 0 [incr nRestants -1]]
foreach AA $LesAAsRestants Score $LesScores {
set MatriceDeSimilarite($AACourant,$AA) $Score
set MatriceDeSimilarite($AA,$AACourant) $Score
}
set LesAAsRestants [lrange $LesAAsRestants 1 end]
}
foreach AA $LesAAs {
set Ligne ""
foreach BB $LesAAs {
append Ligne " [format "%4.1f" [set MatriceDeSimilarite($AA,$BB)]]"
}
}
}
set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre Sequences]
if {$NombreDeSequences<2} { return {} }
foreach NomSeq $LesSequencesDansLOrdre {
if {$NomSeq==$A} { set SeqA [set Sequences($NomSeq)] }
if {$NomSeq==$B} { set SeqB [set Sequences($NomSeq)] }
}
set SeqA [string toupper $SeqA]
set SeqB [string toupper $SeqB]
set lSeqA [string length $SeqA]
set lSeqB [string length $SeqB]
set CumulScore 0
set nCumulScore 0
set CumulId 0
set nCumulId 0
set Commun ""
set LongVraieA 0
set LongVraieB 0
for {set i 0} {$i<$lSeqA} {incr i} {
if {$i >= $lSeqB} { break }
set AA [string range $SeqA $i $i]
set BB [string range $SeqB $i $i]
if { ! [regexp {\.} $AA]} { incr LongVraieA }
if { ! [regexp {\.} $BB]} { incr LongVraieB }
if { $AA != $BB } {
append Commun " "
incr nCumulId
} else {
if { ! [regexp {\.} $AA]} { incr CumulId }
append Commun $AA
incr nCumulId
}
if { ! [info exists MatriceDeSimilarite($AA,$BB)]} { continue }
set Score [set MatriceDeSimilarite($AA,$BB)]
set CumulScore [expr $CumulScore + $Score]
incr nCumulScore
}
set nCumulScore [Maxi 1 $nCumulScore]
set PI [expr $CumulId*100/[Maxi 1 [Mini $LongVraieA $LongVraieB]]]
set PS [expr $CumulScore*1.0/$nCumulScore]
return "$PI % identite et $PS moyenne de similarite ($Entete)"
}
proc LesHeadersDeLaBanqueBlast {B {Hr "nhr"}} {
global RepertoireDuGenome
Wup "Searches for the correct bank and returns the list of header from the .nhr file"
set Loc "$RepertoireDuGenome/banques"
set Glo "/catalog/blast"
foreach BHr [list "$B.$Hr" "$Loc/$B.$Hr" "$Glo/$B.$Hr" "NotFound"] {
if {[file exists $BHr]} { break }
}
if {$BHr=="NotFound"} { return {} }
set Headers [ContenuDuFichier $BHr]
regsub -all {(gnl\|BL_ORD_ID\|[0-9]+ +|lcl\|)} $Headers "\n" Headers
return [split [string trim $Headers "\n"] "\n"]
}
proc SNduFNgcg N {
return [SNvsLNgcg $N sn]
}
proc LNduFNgcg N {
return [SNvsLNgcg $N ln]
}
proc SNduLNgcg N {
return [SNvsLNgcg $N sn]
}
proc LNduSNgcg N {
return [SNvsLNgcg $N ln]
}
proc FNduSNgcg N {
return [SNvsLNgcg $N fn]
}
proc FNduLNgcg N {
return [SNvsLNgcg $N fn]
}
proc SNvsLNgcg {N x} {
global RepertoireDuGenome
global SNvsLNgcg
set N [string toupper $N]
if {[info exists SNvsLNgcg($N,$x)]} { return [set SNvsLNgcg($N,$x)] }
if {[info exists SNvsLNgcg("EstCharge")]} { return "" }
set LesHeaders {}
set FichierDesHeaders "$RepertoireDuGenome/banques/gcgheaders"
if {[file exists $FichierDesHeaders]} {
set LesHeaders [LesLignesDuFichier $FichierDesHeaders]
} else {
set LesFichiersHeader [glob -nocomplain "/genome/*/*.header"]
if {$LesFichiersHeader!={}} {
foreach FichierHeader [glob -nocomplain "/genome/*/*.header"] {
set Header [string toupper [PremiereLigneDuFichier $FichierHeader]]
lappend LesHeaders $Header
}
if {[OuiOuNon "Do I create the file $FichierDesHeaders ?"]} {
SauveLesLignes $LesHeaders dans $FichierDesHeaders
}
}
}
foreach Header $LesHeaders {
set Header [string toupper $Header]
set F [StringApres "NAME:" dans $Header]
set L [StringApres "LN:" dans $Header]
set S [StringApres "SN:" dans $Header]
lappend SNvsLNgcg($F,sn) $S
lappend SNvsLNgcg($F,ln) $L
set SNvsLNgcg($L,fn) $F
set SNvsLNgcg($S,fn) $F
set SNvsLNgcg($L,sn) $S
set SNvsLNgcg($S,ln) $L
}
set SNvsLNgcg("EstCharge") 1
return [SNvsLNgcg $N $x]
}
proc tp {} {
set FichierGB "HS09:NT008421_29.gbtags"
Espionne [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"]
}
proc LesBornesDuCDS Texte {
regsub -all "(" $Texte ""
regsub -all "join" $Texte "\[JoinCDS " Texte
regsub -all "complement" $Texte "\[ComplementCDS " Texte
}
proc DecortiqueGBTags {aOS aOC aSeqADN {Fichier ""}} {
upvar $aOS OS
upvar $aOC OC
upvar $aSeqADN SeqADN
global RepertoireDuGenome
set Avertir 0
set LesClefsInteressantes {gene note product translation protein_id dbx_ref function}
if {$Fichier==""} {
set Fichier [ButineArborescence All $RepertoireDuGenome]
if {$Fichier==""} { return "" }
}
set OS ""
set LaSuiteEstPourOC 0
set OC ""
set LaSuiteEstPourDE 0
set DE ""
set LaSuiteEstPourCDS 0
set LaSuiteEstPourADN 0
set LongueurLue -1
set RogneEnDebutSIlFaut 1
set LesBornes {}
set LeADN {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if {$LaSuiteEstPourADN} {
if {[regexp "^ORIGIN" $Ligne]} { continue }
if {[regexp {\.\.} $Ligne]} { continue }
if {[regexp "//" $Ligne]} { break }
regsub -all {[ 0-9]} $Ligne "" LigneADN
lappend LeADN $LigneADN
continue
}
if {[regexp "^BASE COUNT " $Ligne] || \
[regexp "^SQ" $Ligne] || \
[regexp {^ORIGIN( |$)} $Ligne] || \
[regexp {[^0-9]\.\. *$} $Ligne]} {
set LaSuiteEstPourADN 1
continue
}
if { ! $LaSuiteEstPourADN} {
regsub {\. \.} $Ligne ".." Ligne
}
if {[regexp "^ACCESSION " $Ligne]} {
regsub "^ACCESSION " $Ligne "" Access
lappend LeRetour "/Access=$Access"
}
if {[regexp -nocase "^DEFINITION " $Ligne]} {
regsub "^DEFINITION " $Ligne "" DE
set DE [string trim $DE]
set LaSuiteEstPourDE 1
continue
}
if {$LaSuiteEstPourDE} {
if {[regexp "^ " $Ligne]} {
append DE " [string trim $Ligne]"
} else {
set DE [string trim $DE]
lappend LeRetour "/product=$DE"
set LaSuiteEstPourDE 0
}
continue
}
if {[regexp -nocase "^ ORGANISM " $Ligne]} {
set Genre "Inconnu"
set Espece "inconnu"
scan $Ligne "%s %s %s" Key Genre Espece
set OS "$Genre $Espece"
lappend LeRetour "/OS=$OS"
set LaSuiteEstPourOC 1
continue
}
if {$LaSuiteEstPourOC} {
if {[regexp "^ " $Ligne]} {
append OC "[string trim $Ligne] "
} else {
set OC [string trim $OC]
lappend LeRetour "/OC=$OC"
set LaSuiteEstPourOC 0
}
continue
}
}
set SeqADN [join $LeADN ""]
lappend LeRetour "/DNA=$SeqADN"
return $LeRetour
}
proc ProteinePreditePourTous {{CommenceIci ""}} {
global RepertoireDuGenome
set Rep "$RepertoireDuGenome/genscanpredictions"
if { ! [file exists $Rep]} { File mkdir $Rep }
foreach Nom [ListeDesPABs] {
Espionne $Nom
if {$CommenceIci!="" && $Nom!=$CommenceIci} { continue }
set CommenceIci ""
set PolyLoc [PolyLocalise $Nom]
if { ! [regexp "MonoLocalization|MayBePolyLocalization" $PolyLoc]} { continue }
set FichierGSP "$Rep/$Nom"
if {[file exists $FichierGSP]} { continue }
# ProteinePredite $Nom "FromFile"
ProteinePredite $Nom
}
}
proc ProteinePredite {Nom {Homologue ""} {Write ""}} {
global RepertoireDuGenome
Wup "Creates the TFA file of the predicted protein, writes in info file. Returns the TFA file name"
if {$Write==""} { set Write 1 } else { set Write 0 }
set RepGSPredictions "$RepertoireDuGenome/genscanpredictions"
if { ! [file exists $RepGSPredictions]} { File mkdir $RepGSPredictions }
set FichierGSP "$RepGSPredictions/$Nom"
if {$Homologue=="FromFile"} {
set Homologue ""
if {[file exists $FichierGSP]} {
return [ContenuDuFichier $FichierGSP]
} else {
if {[regexp "no overlap" [ExtraitInfo $Nom "GS"]]} { return "" }
}
}
set LesHomologies [ChaqueSegmentDuBlastN $Nom]
EspionneL $LesHomologies
if {$Homologue==""} {
set Homologue [lindex $LesHomologies 0]
}
scan $Homologue "%s" Voulu
foreach Homologie $LesHomologies {
ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga \
PourcentageIdentiteCacheDansScore Expect \
DebutQuery FinQuery DebutSbjct FinSbjct
if { ! [string compare [string toupper $Voulu] [string toupper $ChroContigTroncon]]} {
lappend LesBornes $DebutSbjct $FinSbjct
} else {
if {[info exists LesBornes]} { break }
}
}
if { ! [info exists LesBornes] } { return "" }
set LesBornes [lsort -integer $LesBornes]
set Gauche [lindex $LesBornes 0]
set Droite [lindex $LesBornes end]
set TexteGS [GenScanEnStock $Voulu]
if {$TexteGS==""} {
set TexteGS [GenScan [ContigComplet $Voulu]]
GenScanEnStock $Voulu $TexteGS
}
foreach Prot [DecortiqueGenScan All All Numbers $TexteGS] {
set G [DecortiqueGenScan $Prot All Gauche]
set D [DecortiqueGenScan $Prot All Droite]
if { $Gauche <= $D && $G <= $Droite } {
if {$Write} { InformeSansDemander $Nom "=GS: overlap found with a predicted protein" }
set BonneProt $Prot
foreach Exon [DecortiqueGenScan $BonneProt All Numbers] {
if {[info exists Fin3] && [info exists Debut3]} {break}
set Sens [DecortiqueGenScan $BonneProt $Exon Sens]
set B [DecortiqueGenScan $BonneProt $Exon Begin]
set E [DecortiqueGenScan $BonneProt $Exon End]
set Nature [DecortiqueGenScan $BonneProt $Exon Nature]
if { $Nature=="PlyA" } {
if {$Sens=="+"} { set Fin3 $E } else { set Debut3 $E}
}
if { $Nature=="Term" || $Nature=="Sngl" } {
if {$Sens=="+"} { set Debut3 $B } else { set Fin3 $B }
}
}
if {![info exists Fin3] || ![info exists Debut3]} {
if {$Write} { InformeSansDemander $Nom "=GS3: 3' region not found by GenScan" }
} else {
Espionne "$Debut3 $Fin3"
if {$Gauche <= $Fin3 && $Debut3 <= $Droite} {
if {$Write} { InformeSansDemander $Nom "=GS3: in 3' region " }
} else {
if {$Write} { InformeSansDemander $Nom "=GS3: not in 3' region" }
set DansIntron 1
foreach Exon [DecortiqueGenScan $BonneProt All Numbers] {
set B [DecortiqueGenScan $BonneProt $Exon Begin]
set E [DecortiqueGenScan $BonneProt $Exon End]
set Nature [DecortiqueGenScan $BonneProt $Exon Nature]
if {($Gauche <= $E && $B <= $Droite) && $Nature!="Prom"} {set DansIntron 0}
}
if {$DansIntron} {
if {$Write} { InformeSansDemander $Nom "=GSE: not in an exon" }
} else {
if {$Write} { InformeSansDemander $Nom "=GSE: in an exon" }
}
}
}
set TFA [DecortiqueGenScan $Prot All TFA]
if {$Write} {
set Fichier [Sauve $TFA dans $FichierGSP]
return $Fichier
} else {
return $TFA
}
}
}
if {$Write} { InformeSansDemander $Nom "=GS: no overlap with any predicted protein" }
return ""
}
proc TestDecortiqueGenScan {} {
set X [DecortiqueGenScan All All Numbers [ContenuDuFichier "IT0002.gsc"]]
Espionne $X
Espionne [DecortiqueGenScan 1 All Gauche]
Espionne [DecortiqueGenScan 1 All Droite]
foreach N [DecortiqueGenScan 1 All Numbers] {
Espionne [DecortiqueGenScan 1 $N Begin]
Espionne [DecortiqueGenScan 1 $N End]
}
exit
}
proc DecortiqueGenScan {Prot Exon Quoi {Texte ""}} {
global DecortiqueGenScan
Wup "Prot can be All or a number"
Wup "Exon can be All or a number"
Wup "Quoi can be list of Protein numbers, Gauche, Droite, TFA, TFAo, Nature, Sens, Begin, End or Proba"
if {$Texte==""} {
if {[info exists DecortiqueGenScan($Prot,$Exon,$Quoi)]} { return [set DecortiqueGenScan($Prot,$Exon,$Quoi)] }
return {}
} else {
if {[info exists DecortiqueGenScan]} { unset DecortiqueGenScan }
}
set OnAttendBeginEnd 1
foreach Ligne [split $Texte "\n"] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
if {$OnAttendBeginEnd} {
if { ! [regexp {Begin[ \.]*End} $Ligne]} { continue }
set OnAttendBeginEnd 0
continue
}
if {[regexp "Predicted peptide sequence" $Ligne]} { continue }
if {[regexp {^ *[0-9]+} $Ligne]} {
if {[info exists Prob]} {unset Prob}
scan $Ligne "%s %s %s %d %d %d %d %d %d %d %d %f %f" \
sPE N S D F Len Fr Ph I Do CodRg Prob T
regsub {\.} $sPE " " sPE
scan $sPE "%s %s" P E
set Nature($P,$E) $N
set Sens($P,$E) $S
set Sens($P) $S
if {[info exists Prob]} {set Proba($P,$E) $Prob}
if {$S=="+"} {
set Begin($P,$E) $D
set End($P,$E) $F
if { ! [info exists Gauche($P)]} { set Gauche($P) $D }
set Droite($P) $F
} else {
set Begin($P,$E) $F
set End($P,$E) $D
if { ! [info exists Gauche($P)]} { set Gauche($P) $F }
set Droite($P) $D
}
if { ! [info exists DejaVu($P)]} { lappend LesPs $P}
set DejaVu($P) 1
lappend LesEs($P) $E
continue
}
if {[regexp "^>" $Ligne]} {
set LigneO $Ligne
regsub -all {[>\|]} $Ligne " " Ligne
scan $Ligne "%s %s %s" ChroContig sP sLong
regexp {_[0-9]+$} $sP P
regsub "_" $P "" P
regsub "_aa$" $sLong "" Long
regsub "\:" $ChroContig "_" Access
set Entete ">${Access}_GS_$P found by GenScan in $ChroContig $Long aa"
set CurrentP $P
set LeTFAo($CurrentP) [list $LigneO]
set LeTFA($CurrentP) [list $Entete]
continue
}
lappend LeTFAo($CurrentP) $Ligne
lappend LeTFA($CurrentP) $Ligne
}
set DecortiqueGenScan(All,All,Numbers) $LesPs
foreach P $LesPs {
set DecortiqueGenScan($P,All,Gauche) [set Gauche($P)]
set DecortiqueGenScan($P,All,Droite) [set Droite($P)]
set DecortiqueGenScan($P,All,Numbers) [set LesEs($P)]
set DecortiqueGenScan($P,All,Sens) [set Sens($P)]
set DecortiqueGenScan($P,All,TFAo) [join [set LeTFAo($P)] "\n"]
set DecortiqueGenScan($P,All,TFA) [join [set LeTFA($P)] "\n"]
foreach E [set LesEs($P)] {
set DecortiqueGenScan($P,$E,Nature) [set Nature($P,$E)]
set DecortiqueGenScan($P,$E,Sens) [set Sens($P,$E)]
set DecortiqueGenScan($P,$E,Begin) [set Begin($P,$E)]
set DecortiqueGenScan($P,$E,End) [set End($P,$E)]
if {[info exists Proba($P,$E)]} {
set DecortiqueGenScan($P,$E,Proba) [set Proba($P,$E)]
}
}
}
return [DecortiqueGenScan $Prot $Exon $Quoi]
}
proc AfficheContigComplet Selection {
foreach Ligne [split $Selection "\n"] {
set Ligne [OteSuperfluPourFetch $Ligne]
scan $Ligne "%s" AccessDuFragment
set F [AfficheVariable [ContigComplet $AccessDuFragment] "AvecBlaste" $AccessDuFragment]
}
return $F
}
proc ContigEnStock {Access {TFA ""}} {
global RepertoireDuGenome
global IgnoreStockcontigs
if {[info exists IgnoreStockcontigs] && $IgnoreStockcontigs} { return "" }
set SizePlease 0
if {[regexp -nocase {^SizePlease$} $TFA]} {
set TFA ""
set SizePlease 1
}
set FileNamePlease 0
if {[regexp -nocase {^FileNamePlease$} $TFA]} {
set TFA ""
set FileNamePlease 1
}
regsub {_[0-9]+$} $Access "" Access
regsub {\:} $Access "_" Access
set Access [string toupper $Access]
set Stock "$RepertoireDuGenome/stockcontigs"
while { ! [file exists $Stock]} {
if {[OuiOuNon "$Stock doesn't exist.\nDo I link to an existing directory ?"]} {
set Ancien [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
if {$Ancien==""} { continue }
exec ln -s $Ancien $Stock
continue
}
if {[OuiOuNon "$Stock doesn't exist.\nDo I create directory ?"]} {
File mkdir $Stock
continue
}
if {[OuiOuNon "Do I ignore all about stockcontigs ?"]} { set IgnoreStockcontigs 1 ; return "" }
}
set Fichier "$Stock/$Access"
if {$SizePlease} {
if {[file exists $Fichier]} {
return [string length [QueLaSequenceDuTFA $Fichier]]
} else {
return -1
}
}
if {$FileNamePlease} {
if {[file exists $Fichier]} {
return $Fichier
} else {
return ""
}
}
if {$TFA==""} {
if {[file exists $Fichier]} { return [ContenuDuFichier $Fichier] }
return ""
}
if {[string index $TFA 0]!=">"} {
FaireLire "You want to store an illegal file format in $Fichier"
return ""
}
return [Sauve $TFA dans $Fichier]
}
proc AccessDuContigDuFragment AccessDuFragment {
regsub {_[0-9]+$} $AccessDuFragment "" AccessDuContig
return $AccessDuContig
}
proc ContigComplet AccessDuFragment {
if {[regexp "^Chro0_" $AccessDuFragment]} { return "" }
set AccessDuContig [AccessDuContigDuFragment $AccessDuFragment]
set TFA [ContigEnStock $AccessDuContig]
if {$TFA!=""} { return $TFA }
if {[regexp -nocase {[a-z]+[0-9]*_[a-z]+} $AccessDuFragment]} {
regsub "_" $AccessDuFragment ":" AccessAChercher
} else {
set AccessAChercher $AccessDuFragment
}
set LeFragmentOrigine [LaSequenceDesBanques $AccessAChercher $AccessAChercher AccessOK "OnVeutNature"]
if {$LeFragmentOrigine=={}} {
if { ! [regexp {_[0-9]+} $AccessAChercher]} {
foreach Fra {"01" "1" "001" "0001"} {
set FragmentAChercher "${AccessAChercher}_$Fra"
set LeFragmentOrigine [LaSequenceDesBanques $FragmentAChercher $FragmentAChercher AccessOK "OnVeutNature"]
if {$LeFragmentOrigine!={}} { break }
}
}
if {$LeFragmentOrigine=={}} { return "" }
}
regexp -nocase {^[a-z][a-z0-9]*(\:|_)} $AccessDuFragment Chro
regsub "_" $Chro ":" Chro
set OnAttendSplit 1
set OnAttendFragment 0
set nSeqLues 0
set Tout ""
foreach Ligne $LeFragmentOrigine {
if {$OnAttendSplit} {
if { ! [regexp "Sequence split into" $Ligne]} { continue }
set nSeq [IntegerApres "Sequence split into" dans $Ligne]
set OnAttendSplit 0
set OnAttendFragment 1
continue
}
if {$OnAttendFragment} {
if { ! [regexp "Fragment Name" $Ligne]} { continue }
set OnAttendFragment 0
continue
}
scan $Ligne "%s %d %d" Access Debut Fin
set Access "$Chro$Access"
set LeFragment [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNature"]
if {$LeFragment=={}} { return "" }
lappend LesFragments $Access
set TFA [SequenceFormatTFA_l $LeFragment $Access "gcg"]
set Seq [QueLaSequenceDuTexteTFA $TFA]
if {[incr nSeqLues]<$nSeq} {
set Seq [string range $Seq 0 end-10000]
}
append Tout $Seq
if {$nSeqLues==$nSeq} { break }
}
if {$OnAttendSplit} {
set TFA [SequenceFormatTFA_l $LeFragmentOrigine $AccessDuContig "gcg"]
} else {
set Entete "$AccessDuContig complete contig made with fragments [lindex $LesFragments 0] to [lindex $LesFragments end]"
set TFA [SequenceFormatTFA $Tout $Entete "nucbrut"]
}
ContigEnStock $AccessDuContig $TFA
return $TFA
}
proc TrieLesExons ListeDesExons {
foreach Homologie $ListeDesExons {
ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga \
PourcentageIdentiteCacheDansScore Expect \
DebutQuery FinQuery DebutSbjct FinSbjct
lappend LesDebuts "$DebutSbjct"
set MonHomo($DebutSbjct) $Homologie
if {[expr ($DebutQuery-$FinQuery)*($DebutSbjct-$FinSbjct)>0]} {
set Sens increasing
} else {
set Sens decreasing
}
}
foreach DebutSbjct [lsort -$Sens -integer $LesDebuts] {
lappend LesTries [set MonHomo($DebutSbjct)]
}
return $LesTries
}
proc TrieLesExonsEtPurgeLesOverlaps ListeDesHomologues {
set LesTries {}
set ListeDesExons {}
set OldChroContigTroncon "Bidon"
foreach Homologie $ListeDesHomologues {
ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga \
PourcentageIdentiteCacheDansScore Expect \
DebutQuery FinQuery DebutSbjct FinSbjct
if {$OldChroContigTroncon!="Bidon" && $ChroContigTroncon!=$OldChroContigTroncon} {
set LesTries [concat $LesTries [TrieLesExons $ListeDesExons]]
set ListeDesExons {}
}
set OldChroContigTroncon $ChroContigTroncon
lappend ListeDesExons $Homologie
}
set LesTries [concat $LesTries [TrieLesExons $ListeDesExons]]
set ListeDesExons {}
foreach Homologie $LesTries {
ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga \
PourcentageIdentiteCacheDansScore Expect \
DebutQuery FinQuery DebutSbjct FinSbjct
set S "$DebutSbjct,$FinSbjct"
if { ! [info exists nHits($ChroContigTroncon)]} { set nHits($ChroContigTroncon) 0 }
incr nHits($ChroContigTroncon)
if {[info exists DejaVu($S)]} {
lappend LesPurgeables [set DejaVu($S)]
lappend LesPurgeables $Homologie
set DejaDejaVu($S) [set DejaVu($S)]
}
set DejaVu($S) $Homologie
}
foreach Homologie $LesTries {
ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga \
PourcentageIdentiteCacheDansScore Expect \
DebutQuery FinQuery DebutSbjct FinSbjct
set S "$DebutSbjct,$FinSbjct"
if {[info exists DejaPurge($S)]} { continue }
if {[info exists DejaDejaVu($S)]} {
set DejaPurge($S) 1
scan [set DejaDejaVu($S)] "%s" CCT1
scan [set DejaVu($S)] "%s" CCT2
if {[set nHits($CCT1)] > [set nHits($CCT2)]} {
lappend LesPurges [set DejaDejaVu($S)]
} else {
lappend LesPurges [set DejaVu($S)]
}
continue
}
lappend LesPurges $Homologie
}
return $LesPurges
}
proc PolyLocalise {NomVoulu {Color ""} {Recalcule ""}} {
global RepertoireDuGenome
global PolyLocalise
global AskForCalculatePolylocalise
if { ! [info exists AskForCalculatePolylocalise]} { set AskForCalculatePolylocalise 1 }
set Liste $NomVoulu
if {$Recalcule==""} {
set Recalcule 0
} else {
set Recalcule 1
if {[info exists PolyLocalise]} { unset PolyLocalise }
}
set CreeFichier 0
if {! $Recalcule && $NomVoulu=="CreateFile"} {
if {[info exists PolyLocalise]} { unset PolyLocalise }
set CreeFichier 1
}
if { ! [string compare [string toupper $Color] [string toupper "ColorPlease"]]} {
set X C
} else {
set X T
}
set ReLoc(NoBlastFile,T) "NoBlastFile"
set ReLoc(NoLocalization,T) "NoLocalization"
set ReLoc(MonoLocalization,T) "MonoLocalization"
set ReLoc(MayBePolyLocalization,T) "MayBePolyLocalization"
set ReLoc(PolyLocalization,T) "PolyLocalization"
set ReLoc(NoBlastFile,C) "grey"
set ReLoc(NoLocalization,C) "white"
set ReLoc(MonoLocalization,C) "blue"
set ReLoc(MayBePolyLocalization,C) "orange"
set ReLoc(PolyLocalization,C) "red"
if {[info exists PolyLocalise($NomVoulu,$X)]} { return [set PolyLocalise($NomVoulu,$X)] }
if {[info exists PolyLocalise("EstCharge")]} { return [set ReLoc(NoLocalization,$X)] }
if { ! $Recalcule } {
global FichierPolyLocaliseDefaut
if {[info exists FichierPolyLocaliseDefaut]} {
set FichierLocalise $FichierPolyLocaliseDefaut
} else {
set FichierLocalise "[RepertoireDuGenome]/fiches/polylocalise"
}
if { ! $CreeFichier && [file exists $FichierLocalise]} {
foreach Ligne [LesLignesDuFichier $FichierLocalise] {
scan $Ligne "%s %s" NomLu Valeur
set PolyLocalise($NomLu,T) $Valeur
set PolyLocalise($NomLu,C) [set ReLoc($Valeur,C)]
}
set PolyLocalise("EstCharge") 1
if {[info exists PolyLocalise($NomVoulu,$X)]} { return [set PolyLocalise($NomVoulu,$X)] }
if {[info exists PolyLocalise("EstCharge")]} { return [set ReLoc(NoLocalization,$X)] }
}
if {$CreeFichier || ($AskForCalculatePolylocalise && \
[OuiOuNon "Do I calculate all polylocalization and create $FichierLocalise"])} {
set Liste [ListeDesPABs]
set CreeFichier 1
} else {
if {$AskForCalculatePolylocalise && [OuiOuNon "Do I stop asking ?"]} {
set AskForCalculatePolylocalise 0
}
set Liste [list $NomVoulu]
set CreeFichier 0
}
}
foreach Nom $Liste {
set FichierBlastN "$RepertoireDuGenome/blastn/$Nom"
if { ! [file exists $FichierBlastN]} {
set Valeur "NoBlastFile"
set PolyLocalise($Nom,T) $Valeur
set PolyLocalise($Nom,C) [set ReLoc($Valeur,C)]
continue
}
set SeuilAcceptable 1.e-3
set SeuilDeuxBons 1.e-3
set SeuilEcartExpo 0
set LesHomologues [ChaqueSegmentDuBlastN $FichierBlastN]
if {$LesHomologues=={}} {
set Valeur "NoLocalization"
set PolyLocalise($Nom,T) $Valeur
set PolyLocalise($Nom,C) [set ReLoc($Valeur,C)]
continue
}
set A 9999.
set B 9999.
set AouB "A"
set OldChroContigTroncon "Bidon"
foreach Homologie $LesHomologues {
ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga \
PourcentageIdentiteCacheDansScore Expect \
DebutQuery FinQuery DebutSbjct FinSbjct
if {$OldChroContigTroncon=="Bidon" || $ChroContigTroncon==$OldChroContigTroncon} {
set OldChroContigTroncon $ChroContigTroncon
if {[expr [set $AouB] > $Expect]} {
set $AouB $Expect
set Access$AouB $ChroContigTroncon
}
continue
}
set OldChroContigTroncon $ChroContigTroncon
if {$AouB=="B"} { break }
set AouB "B"
set $AouB $Expect
set Access$AouB $ChroContigTroncon
}
if {$A > $SeuilAcceptable } {
set Valeur "NoLocalization"
set PolyLocalise($Nom,T) $Valeur
set PolyLocalise($Nom,C) [set ReLoc($Valeur,C)]
continue
}
if {$B > $SeuilAcceptable} {
set Valeur "MonoLocalization"
set PolyLocalise($Nom,T) $Valeur
set PolyLocalise($Nom,C) [set ReLoc($Valeur,C)]
continue
}
if {0 && $B <= $SeuilDeuxBons} {
set Valeur "PolyLocalization"
set PolyLocalise($Nom,T) $Valeur
set PolyLocalise($Nom,C) [set ReLoc($Valeur,C)]
continue
}
if {$A==0.0} {
set eA -200
} else {
set A [string tolower $A]
set eA [IntegerApres "e" dans $A]
}
if {$B==0.0} {
set eB -200
} else {
set B [string tolower $B]
set eB [IntegerApres "e" dans $B]
}
set eD [expr $eB-$eA]
Espionne $eD
if {$eD > $SeuilEcartExpo } {
set Valeur "MayBePolyLocalization"
set PolyLocalise($Nom,T) $Valeur
set PolyLocalise($Nom,C) [set ReLoc($Valeur,C)]
continue
} else {
set Valeur "PolyLocalization"
set PolyLocalise($Nom,T) $Valeur
set PolyLocalise($Nom,C) [set ReLoc($Valeur,C)]
continue
}
}
if {$CreeFichier} {
foreach Nom $Liste {
lappend Sortie "$Nom [set PolyLocalise($Nom,T)]"
}
set FichierLocalise [SauveLesLignes $Sortie dans $FichierLocalise]
}
if {$NomVoulu=="CreateFile"} { return $FichierLocalise }
if {[info exists PolyLocalise($NomVoulu,$X)]} { return [set PolyLocalise($NomVoulu,$X)] }
return [set Reloc(NoLoc,$X)]
}
proc QuelMaskPourTous {{Quoi ""}} {
foreach Nom [ListeDesPABs] {
Espionne [QuelMask $Nom $Quoi]
}
exit
}
proc QuelMask {Nom {Color ""}} {
global RepertoireDuGenome
global CouleurDuFond
set Color [string equal -nocase $Color "ColorPlease"]
set CouleurDuMask(NoAnnotationFound) "lightgrey"
set CouleurDuMask(NoSequenceToMask) "white"
set CouleurDuMask(NoTfaFile) "black"
set CouleurDuMask(NoMaskFile) "grey"
set CouleurDuMask(NoRepeatToMask) "green"
set CouleurDuMask(PartiallyMasked) "orange"
set CouleurDuMask(TotallyMasked) "red"
set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom"
if { ! [file exists $FichierTFA]} {
set Annotation "NoTfaFile"
if {$Color} {
return [set CouleurDuMask($Annotation)]
} else {
return $Annotation
}
}
set FichierMAS "$RepertoireDuGenome/nucmask/$Nom"
if { ! [file exists $FichierMAS]} {
set Annotation "NoMaskFile"
if {$Color} {
return [set CouleurDuMask($Annotation)]
} else {
return $Annotation
}
}
set LeMAS [LesLignesDuFichier $FichierMAS]
set Entete [lindex $LeMAS 0]
set Annotation "NoAnnotationFound"
foreach Possible [list \
NoSequenceToMask \
NoRepeatToMask \
TotallyMasked \
PartiallyMasked \
NoSequenceToReMask \
NoRepeatToReMask \
TotallyReMasked \
PartiallyReMasked \
NoSequenceToMRM \
NoRepeatToMRM \
TotallyMRM \
PartiallyMRM \
Bidon] {
if {[regexp $Possible $Entete Annotation]} { break }
}
regsub "allyMRM$" $Annotation "allyMRMed" Annotation
regsub "ReMask|MRM" $Annotation "Mask" Annotation
if {$Color} {
return [set CouleurDuMask($Annotation)]
} else {
return $Annotation
}
}
proc rrQuelMask {Nom {Color ""}} {
global RepertoireDuGenome
global CouleurDuFond
set Color [string equal -nocase $Color "ColorPlease"]
set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom"
set FichierMAS "$RepertoireDuGenome/nucmask/$Nom"
set CouleurDuMask(NoSequenceToMask) "white"
set CouleurDuMask(NoMaskFile) "grey"
set CouleurDuMask(NoRepeatToMask) "green"
set CouleurDuMask(PartiallyMasked) "orange"
set CouleurDuMask(TotallyMasked) "red"
if { ! [file exists $FichierMAS]} {
set Annotation "NoMaskFile"
if {$Color} {
return [set CouleurDuMask($Annotation)]
} else {
return $Annotation
}
}
set LeTFA [LesLignesDuFichier $FichierTFA]
set TFA [join [lrange $LeTFA 1 end] ""]
set LeMAS [LesLignesDuFichier $FichierMAS]
set Entete [lindex $LeMAS 0]
set Annotation ""
scan $Entete "%s %s" NomLu Annotation
if {[regexp "NoSequenceToMask|NoRepeatToMask|TotallyMasked|PartiallyMasked" $Annotation]} {
if {$Color} {
return [set CouleurDuMask($Annotation)]
} else {
return $Annotation
}
}
set ToutMAS [join [lrange $LeMAS 0 end] "\n"]
set MAS [join [lrange $LeMAS 1 end] ""]
if {[string equal $TFA $MAS]} {
set Annotation "NoRepeatToMask"
} else {
set LongueurInitiale [string length $TFA]
if {$LongueurInitiale==0} {
set Annotation NoSequenceToMask
} else {
set SeuilPourcentage 90
regsub -all -nocase "N" $MAS "" SeqMaskSansN
regsub -all -nocase "N" $TFA "" SeqSansN
set LongSeqMaskSansN [string length $SeqMaskSansN]
set LongSeqSansN [string length $SeqSansN]
set NbNuclMasques [expr $LongSeqSansN-$LongSeqMaskSansN]
set PourcentageMasque [expr $NbNuclMasques*100/$LongueurInitiale]
if {[expr $PourcentageMasque>$SeuilPourcentage]} {
set Annotation "TotallyMasked"
} else {
set Annotation "PartiallyMasked"
}
}
}
regsub ">$Nom " $ToutMAS ">$Nom $Annotation " ToutMAS
Sauve $ToutMAS dans $FichierMAS
if {$Color} {
return [set CouleurDuMask($Annotation)]
} else {
return $Annotation
}
}
proc RepeatMaskerDuContigEnStock Access {
global RepertoireDuGenome
set AccessMasque "${Access}_mask"
set TFAMask [ContigEnStock $AccessMask]
if {$TFAMask!=""} { return $TFAMask }
set TFA [ContigEnStock $Access]
set TFAMask [RepeatMaskerDuTexte $TFA]
if {[TFAMask==""]} { return $TFA }
ContigEnStock $AccessMask $TFAMask
return $TFAMask
}
proc RepeatMaskerDuTexte {Texte {aRacine ""}} {
set GarderRacine 0
if {$aRacine!=""} {
set GarderRacine 1
upvar $aRacine Racine
}
if {$Texte==""} {
FaireLire "The sequence to mask is empty !! "
set Racine ""
return ""
}
NousAllonsAuBoulot
set Racine [TmpFile "" .].tfa
Sauve $Texte dans $Racine
catch {exec RepeatMasker $Racine -nolow} Message
if { ! [file exists $Racine.masked]} {
FaireLire "Repeatmasker didn't create an output for $Racine\n$Message"
OnRevientDuBoulot
return ""
}
set TexteMask [ContenuDuFichier $Racine.masked]
if { ! $GarderRacine} {
foreach F [glob -nocomplain $Racine*] {
file delete -force $F
}
}
set Racine "[pwd]/$Racine"
OnRevientDuBoulot
return $TexteMask
}
proc RepeatMaskerForAll {} {
foreach Nom [ListeDesPABs] {
set Mask [RepeatMasker $Nom]
Espionne "$Nom $Mask"
}
}
proc RepeatMasker Nom {
global RepertoireDuGenome
Wup "Specific to normal case"
if { ! [file exists "$RepertoireDuGenome/nucmask"]} { File mkdir "$RepertoireDuGenome/nucmask" }
set Keep 1
set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom"
set FichierMASK "$RepertoireDuGenome/nucmask/$Nom"
if { ! [file exists $FichierTFA]} { return "" }
if {$Keep && [file exists $FichierMASK]} { return $FichierMASK }
if {[QueLaSequenceDuTFA $FichierTFA]==""} { return "" }
NousAllonsAuBoulot
set Racine [TmpFile "" .].tfa
File copy $FichierTFA $Racine
Espionne "Je vais lancer RepeatMasker sur $Racine $Nom"
catch {exec RepeatMasker $Racine -nolow} Message
if { ! [file exists $Racine.masked]} {
FaireLire "Repeatmasker didn't create an output for $Racine\n$Message"
OnRevientDuBoulot
return ""
}
File copy $Racine.masked $FichierMASK
if { [file exists "$Racine.tbl"]} {
set TexteTBL [join [LesLignesDuFichier $Racine.tbl] "\n"]
Espionne $TexteTBL
set PourcentMasque [DecortiqueSortieRepeatMasker All Pourcent $TexteTBL]
InformeSansDemander $Nom "=RMPourcent: $PourcentMasque"
set LesRepeats [DecortiqueSortieRepeatMasker All Numbers $TexteTBL]
foreach R $LesRepeats {
set Nature [DecortiqueSortieRepeatMasker $R Nature $TexteTBL]
set nOccs [DecortiqueSortieRepeatMasker $R Occurrences $TexteTBL]
InformeSansDemander $Nom "=RM: $nOccs $Nature"
}
} else {
InformeSansDemander $Nom "=RMPourcent: 0"
}
foreach F [glob -nocomplain $Racine*] {
File delete -force $F
}
OnRevientDuBoulot
QuelMask $Nom
return $FichierMASK
}
proc BonDNA Fichier {
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp ">" $Ligne]} { continue }
if { ! [regexp -nocase {[^ATGC N]} $Ligne]} { continue }
Espionne $Ligne
}
exit
}
proc RunRepeatMaskerEtAffiche Texte {
set TexteMask [RepeatMaskerDuTexte $Texte]
if {$TexteMask==""} { return "" }
return [AfficheVariable $TexteMask "AvecFormateAvecBlaste"]
}
proc RunGenScanEtAffiche FichierTFAOuTexte {
set GSC [GenScan $FichierTFAOuTexte]
if {$GSC==""} { return "" }
return [AfficheVariable $GSC "AvecRien" $FichierTFAOuTexte]
}
proc GenScan {FichierTFAOuTexte {FichierGSC ""} {TailleTroncon 300000} {TailleOverlap 300000}} {
set Previens 1
if {$FichierGSC==""} {
set RetourFichierGSC 0
} else {
set RetourFichierGSC 1
}
if {$FichierGSC=="ReturnTmpfilePlease"} {
set FichierGSC ""
}
if {$FichierGSC!="" && [file exists $FichierGSC]} {
if { ! [OuiOuNon "$FichierGSC already exists. Overwrite ?"]} { return $FichierGSC }
}
if {[regexp "^>" $FichierTFAOuTexte]} {
set CleanTFA 1
set FichierTFA [Sauve $FichierTFAOuTexte dans "[TmpFile].tfa"]
if {$FichierGSC==""} {
regsub "\.tfa$" $FichierTFA ".gsc" FichierGSC
}
} else {
set CleanTFA 0
set FichierTFA $FichierTFAOuTexte
}
if {$FichierGSC==""} {
set FichierGSC "[TmpFile].gsc"
}
Espionne "$FichierTFA $FichierGSC"
set MaxSizeForGenScan [expr $TailleTroncon + $TailleOverlap + 10000]
if {[string length [QueLaSequenceDuTFA $FichierTFA]] < $MaxSizeForGenScan} {
set Message ""
catch {exec genscan "/biolo/genscan/HumanIso.smat" $FichierTFA > $FichierGSC} Message
} else {
foreach FichierTronconTFA [TronconneLeFichierTFA $FichierTFA $TailleTroncon $TailleOverlap "UseSameNameOnTmp"] {
regsub ".tfa$" $FichierTronconTFA "" FichierTronconGSC
set FichierTronconGSC "$FichierTronconGSC.gsc"
GenScan $FichierTronconTFA $FichierTronconGSC $TailleTroncon $TailleOverlap
lappend LesTronconsGSC $FichierTronconGSC
}
ReassembleLesTronconsGenscan $LesTronconsGSC $TailleTroncon $FichierGSC
}
if { ! [file exists $FichierGSC]} {
if {$Previens} {
Espionne "GenScan didn't work. See $FichierTFA"
return ""
}
set GSG ""
}
set GSC [ContenuDuFichier $FichierGSC]
if {$Previens && ! [regexp -nocase {[a-z]} $GSC]} {
FaireLire "Genscan produced an empty output $FichierGSC\nand the following error message : \n$Message"
}
if {$CleanTFA} { File delete -force $FichierTFA }
if {$RetourFichierGSC} {
return $FichierGSC
}
File delete -force $FichierGSC
return $GSC
}
proc FetchContig Selection {
global RepertoireDuGenome
foreach Ligne [split $Selection "\n"] {
if { ! [regexp -nocase {[a-z0-9]+\:[a-z0-9_]+} $Ligne BanqueId]} { continue }
set GCG [FetchCat $BanqueId]
if {$GCG==""} { continue }
AfficheVariable $GCG "AvecFormate" $BanqueId
}
}
proc AfficheChaqueSegmentDuBlastN {Nom {FichierBlast ""} {Selection ""}} {
global RepertoireDuGenome
Wup "Shows only these from Selection, all if empty"
if {$FichierBlast==""} { set FichierBlast "$RepertoireDuGenome/blastn/$Nom" }
if { ! [file exists $FichierBlast]} { return "" }
set SeuilDuBlastN 0.001
set LesVoulus {}
if {$Selection!=""} {
foreach Ligne [split $Selection "\n"] {
scan $Ligne "%s" Voulu
lappend LesVoulus $Voulu
}
if {$LesVoulus=={}} { return "" }
set SeuilDuBlastN 9999.9
}
set LesSegments [ChaqueSegmentDuBlastN $FichierBlast $SeuilDuBlastN $LesVoulus]
set Fen [AfficheVariable [join $LesSegments "\n"] "GrandeLargeur" "ChaqueSegmentDuBlast_$Nom"]
if { ! [regexp "blastn" $FichierBlast]} { return "" }
set B [BoutonneLaFenetre $Fen "Locs on Chromos\nGenScan output" ""]
bind $B <1> "VoirLesLocalisationsDuCDNA $Nom \[selection get\]"
bind $B <Shift-1> "AfficheGenscanDuContig \[selection get\]"
return
}
proc OldChroContigTronconOffsetOrganisme Header {
global SansOffsetEtOrganisme
if {[info exists SansOffsetEtOrganisme] && $SansOffsetEtOrganisme} {
return "0 0 0 0 Inconnu inconnu"
}
Wup "Works well for Homo sapiens only"
scan $Header "%s" BanqueId
regsub ">" $BanqueId "" BanqueId
ScanLaListe [split $BanqueId ":"] Chro Contig
set Troncon "__"
if {[regexp {_[0-9]+$} $Contig Troncon]} {
regsub {_[0-9]+$} $Contig "" Contig
}
set Genre "Genre"
set Espece "Espece"
if {[regexp -nocase "^hs" $Chro]} { set Genre "Homo" ; set Espece "sapiens" }
set Offset 0
if {[regexp "from base" $Header]} {
set Offset [IntegerApres "from base" dans $Header]
incr Offset -1
}
return "$Chro $Contig $Troncon $Offset $Genre $Espece"
}
proc ChroContigTronconOffsetOrganisme Header {
global SansOffsetEtOrganisme
if {[info exists SansOffsetEtOrganisme] && $SansOffsetEtOrganisme} {
return "0 0 0 0 Inconnu inconnu"
}
Wup "Works well for Homo sapiens only"
scan $Header "%s" BanqueId
regsub ">" $BanqueId "" BanqueId
set Chro ""
set Contig ""
ScanLaListe [split $BanqueId ":"] Chro Contig
set Troncon "__"
if {[regexp {_[0-9]+$} $Contig Troncon]} {
regsub {_[0-9]+$} $Contig "" Contig
}
set Genre "Genre"
set Espece "Espece"
set Offset -1
if {[regexp -nocase {^hs[0-9xy(un)]} $Chro]} {
set Genre "Homo"
set Espece "sapiens"
} else {
Wup "We try in with completegenome.frag file"
scan [OffsetEtOrganismeDuFragment $BanqueId] "%d %s %s" Offset Genre Espece
if {$Genre!="" && $Genre!="Genre"} { set Offset -1 }
}
if {$Offset<0} {
set Offset 0
if {[regexp "from base" $Header]} {
set Offset [IntegerApres "from base" dans $Header]
incr Offset -1
}
}
return "$Chro $Contig $Troncon $Offset $Genre $Espece"
}
proc ChaqueSegmentDuBlastN {NomOuFichier {SeuilDuBlastN 0.001} {LesVoulus {}} {AvecLaSeq ""}} {
global RepertoireDuGenome
Wup "Returns only these from Voulus, all if Voulus is empty"
if {$AvecLaSeq==""} {
set AvecLaSeq 0
set EtLaSeq ""
} else {
set AvecLaSeq 1
}
if {[regexp "/" $NomOuFichier] && [file exists $NomOuFichier]} {
set Fichier $NomOuFichier
} else {
set Nom [file tail $NomOuFichier]
set Fichier "$RepertoireDuGenome/blastn/$Nom"
}
if { ! [file exists $Fichier]} { return {} }
set Nom [file tail $Fichier]
set nSequencesTrouves [DecortiqueBlast $Fichier \
$SeuilDuBlastN "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN lPartieSegAli]
if { $nSequencesTrouves == 0 } {
set nCops 0
return {}
}
set PasTous [expr [llength $LesVoulus]>0]
foreach Voulu $LesVoulus {
set VOULU [string toupper $Voulu]
set MoiAussi($VOULU) 1
}
set Offset 0
set ListeDesHomologues {}
set nCops 0
foreach BanqueId $lBanqueId PN $lPN PartieSegAli $lPartieSegAli {
set BANQUEID [string toupper $BanqueId]
if {$PasTous && ! [info exists MoiAussi($BANQUEID)]} { continue }
set nCopsDansCetteSequence 0
if {[info exists Score]} { unset Score }
set CompleteHeader 0
foreach Ligne [lappend PartieSegAli "FinSegAli"] {
if { ! [regexp {[0-9a-zA-Z_]} $Ligne] } { continue }
if {[regexp {^>} $Ligne]} {
set Header $Ligne
set CompleteHeader 1
continue
}
if {$CompleteHeader} {
set CompleteHeader 0
append Header " $Ligne"
scan [ChroContigTronconOffsetOrganisme $Header] "%s %s %s %d %s %s" Chro Contig Troncon Offset Genre Espece
regsub "__" $Troncon "" Troncon
set ChroContigTroncon "$Chro:$Contig$Troncon"
set OrgaComplet "$Genre $Espece"
set Orga [Glossaire $OrgaComplet Court]
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
if { $AvecLaSeq } { set EtLaSeq "\t$SeqSbjct" }
Wup "Je triche en cachant dans Score le PourcentageIdentite"
set PourcentageIdentiteCacheDansScore [format "%6.2f" [expr (100.*$nId)/$nTotal]]
set Homologie "$ChroContigTroncon\t$nCops\t$nCopsDansCetteSequence\t$Orga\t$PourcentageIdentiteCacheDansScore\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq"
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]} {
#rR pour lire aussi les blast+ 2018/11/07
set Key "Query"
if {[regexp "Query:" $Ligne]} { set Key "Query:" }
set DebutQuery [IntegerApres $Key dans $Ligne]
}
set FinQuery [IntegerEnFin de $Ligne]
}
if {[regexp "^Sbjct:?" $Ligne] } {
if { ! [info exists DebutSbjct]} {
set SeqSbjct ""
#rR pour lire aussi les blast+ 2018/11/07
set Key "Sbjct"
if {[regexp "Sbjct:" $Ligne]} { set Key "Sbjct:" }
set DebutSbjct [expr [IntegerApres $Key dans $Ligne] + $Offset]
}
regexp -indices {[0-9]+} $Ligne D
set D [lindex $D 1]
regexp -indices {[0-9]+} [string range $Ligne [incr D] end] F
set F [expr [lindex $F 0]+$D-1]
append SeqSbjct [string trim [string range $Ligne $D $F]]
set FinSbjct [expr [IntegerEnFin de $Ligne] + $Offset]
}
}
}
set ListeDesHomologues [TrieLesExonsEtPurgeLesOverlaps $ListeDesHomologues]
return $ListeDesHomologues
}
proc CorrigeTFA {} {
global RepertoireDuGenome
foreach Nom [ListeDesPABs] {
set FichierTFA "$RepertoireDuGenome/prottfa/$Nom"
if { ! [file exists $FichierTFA]} { FaireLire "$FichierTFA n'existe pas" }
set TFA [ContenuDuFichier $FichierTFA]
Espionne [string range $TFA 0 100]
regsub -nocase {^>[a-z0-9]+ [0-9]+ [0-9]+ [FR]+} $TFA ">$Nom" TFA
Espionne [string range $TFA 0 100]
}
}
proc TousLesEMBLtoGCG {{Rep ""} {Dest ""}} {
global RepertoireDuGenome
if {$Rep==""} { set Rep "$RepertoireDuGenome/nucembl" }
if {$Dest==""} {
regsub "embl" $Rep "" BaseRep
set Dest "${BaseRep}gcg"
}
if { ! [OuiOuNon "Do I create the files in $Dest ?"]} { return }
if {[file exists $Dest]} { File mkdir $Dest }
foreach Fichier [glob -nocomplain "$Rep/*"] {
set Nom [file tail $Fichier]
set Sortie {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp "^SQ " $Ligne]} { append Ligne " .." }
lappend Sortie $Ligne
}
SauveLesLignes $Sortie dans "$Dest/$Nom"
}
FaireLire "Please do following : \ncd $Dest\nand run the gcg command reformat with *"
}
proc EMBLduPDB {aPDB {ACFirst ""}} {
Wup "Calls TFADuPDB which calls fastacmd"
Wup "if no answer searches in /catalog/blast/pdb"
if {$ACFirst=="ACFirst"} { set ACFirst 1 } else { set ACFirst 0 }
set OS [OrganismeDuPDB $aPDB]
set OC [OCduOS $OS]
set GN [MoleculeDuPDB $aPDB]
if {$ACFirst} {
lappend LeEMBL "AC $aPDB"
lappend LeEMBL "ID $aPDB created by Gscope with pdb entry $aPDB"
} else {
lappend LeEMBL "ID $aPDB created by Gscope with pdb entry $aPDB"
lappend LeEMBL "AC $aPDB"
}
lappend LeEMBL "OS $OS"
lappend LeEMBL "OC $OC"
set TFA [string trim [TFADuPDB $aPDB] " \n"]
regsub {[^ ]* } [lindex [split $TFA "\n"] 0] "" DE
if {$TFA==""} {
# return ""
set TFA [TfaDeLaBanqueBlast "/catalog/blast/pdb" $aPDB]
}
if {$TFA==""} { return "" }
if {$DE==""} {
set DE [TextePDB $aPDB "KEYWDS"]
}
if {[regexp {\.{2,} *$} $DE]} { regsub {\.{2,} *$} $DE "" DE }
if {$DE!=""} { lappend LeEMBL "DE $DE" }
if {$GN!=""} { lappend LeEMBL "GN $GN" }
set Seq [join [lrange [split $TFA "\n"] 1 end] "\n"]
regsub -all -nocase {[^A-Z]} $Seq "" Seq
lappend LeEMBL [QueSequenceFormatEMBL $Seq "AvecSQ"]
return [join $LeEMBL "\n"]
}
proc ScanOS {} {
global RepertoireDuGenome
set Repertoire "$RepertoireDuGenome/.."
set FichierDesOSsBrut "$Repertoire/OSbrut"
set FichierDesOSs "$Repertoire/LesOSs"
set FichierDesBonsOSs "$Repertoire/LesBonsOSs"
set FichierDesVulgaireOSs "$Repertoire/VulgaireOSs"
if { ! [file exists $FichierDesOSs]} {
if { ! [file exists $FichierDesOSsBrut]} {
eval exec "grep '^OS' /prot/gcgswissprot/swissprot.ref > $FichierDesOSsBrut"
}
foreach Ligne [LesLignesDuFichier $FichierDesOSsBrut] {
regsub -all {\t} $Ligne " " Ligne
regsub -all {(^OS +)|( *$)} $Ligne "" Texte
if {[regexp {\([^\)]*\,} $Ligne]} {
set BonTexte ""
set I 0
foreach C [split $Texte ""] {
if {$C=="("} { incr I }
if {$C==")"} { incr I -1}
if {$C=="," && $I} { set C " " }
append BonTexte $C
}
set Texte $BonTexte
}
if { ! [regexp {\.$} $Texte]} {
lappend LeOS $Texte
continue
}
while {[regexp " " $Texte]} { regsub -all " " $Texte " " Texte }
lappend LeOS [string trim $Texte]
set OS [join $LeOS " "]
lappend LesOSs $OS
set LeOS {}
}
set LesOSs [lsort -unique $LesOSs]
SauveLesLignes $LesOSs dans $FichierDesOSs
}
foreach Ligne [LesLignesDuFichier $FichierDesOSs] {
regsub {\.$} $Ligne "" Ligne
regsub { and } $Ligne "" Ligne
set LesChamps [split $Ligne ","]
foreach Champ $LesChamps {
set Champ [string trim $Champ]
if {[info exists Strain]} { unset Strain }
if {[info exists Vulgus]} { unset Vulgus }
set I 0
while {[regexp {\(} $Champ]} {
incr I
set P [string last ")" $Champ]
set N 1
while {$N} {
incr P -1
if {$P<0} { FaireLire "Wrong parenthesis in $Ligne" ; break }
set C [string index $Champ $P]
if {$C==")"} { incr N }
if {$C=="("} { incr N -1}
}
set Parent [string rang $Champ $P end]
set Champ [string trim [string range $Champ 0 [incr P -1]]]
if {[regexp -nocase "strain" $Parent]} {
set Strain($I) [string range $Parent 1 end-1]
} else {
set Vulgus($I) [string range $Parent 1 end-1]
}
}
set LesStrains {}
set LesVulguss {}
while {$I} {
if {[info exists Strain($I)]} { lappend LesStrains [set Strain($I)] }
if {[info exists Vulgus($I)]} { lappend LesVulguss [set Vulgus($I)] }
incr I -1
}
set Souche ""
set Vulgaire ""
if {$LesStrains!={}} { set Souche [join $LesStrains " "] }
if {$LesVulguss!={}} { set Vulgaire [join $LesVulguss " "]}
set OS [string trim $Champ]
set OriginOS $OS
if {[regexp -nocase "VIRUS" $OS]} { set OS "VIRUS $OS" }
if {[regexp -nocase "ENDOSYMBIONT" $OS]} { set OS "ENDOSYMBIONT $OS" }
if {[regexp -nocase "ENDOBACTERIUM" $OS]} { set OS "ENDOBACTERIUM $OS" }
set LesMots [split $OS " "]
set OS [join [lrange $LesMots 0 1] " "]
lappend LesBonsOSs $OS
if {$Vulgaire!=""} {
lappend LesOSduVulgaire($Vulgaire) $OS
}
}
set LesBonsOSs [lsort -unique $LesBonsOSs]
}
foreach Vulgaire [array names LesOSduVulgaire] {
set LesOSOS [lsort -unique [set LesOSduVulgaire($Vulgaire)]]
lappend LesVulgairesOSOS "$Vulgaire:[join $LesOSOS ":"]"
}
SauveLesLignes $LesVulgairesOSOS dans $FichierDesVulgaireOSs
SauveLesLignes $LesBonsOSs dans $FichierDesBonsOSs
exit
}
proc SeqNucToSeqPro SeqNuc {
set SeqPro ""
set longueur [string length $SeqNuc]
for {set i 0} {$i<$longueur} {incr i 3} {
set Codon [string range $SeqNuc $i $i+2]
append SeqPro [AAduCodon $Codon]
}
return $SeqPro
}
proc CreeOuTapeTBlastX Banque {
global RepertoireDuGenome
set Liste {}
foreach Fichier [lsort [glob "$RepertoireDuGenome/troustblastx$Banque/TROU3*"]] {
set Nom [file tail $Fichier]
if {[Decede $Nom]} { continue }
# lappend Liste "$Nom [join [OuATapeTBlastX $Fichier $Banque ListeDesDupliques] " "]"
Wup "Commentariser ci-dessus (pour les paralogues par ex.) ou les 2 ci-dessous ou l'un"
# lappend Liste "$Nom [join [OuATapeTBlastX $Fichier $Banque ListeDesOrganismes] " "]"
# lappend Liste "$Nom [join [OuATapeTBlastX $Fichier $Banque ListeDesPositions] " "]"
set Liste [concat $Liste $Nom [OuATapeTBlastX $Fichier $Banque LesSegments]]
}
SauveLesLignes $Liste dans "[RepertoireDuGenome]/fiches/ouatapetbx.$Banque.arenommer"
}
proc EnteteDuTexteTFA {Texte {Quoi "all"}} {
set Entete ""
foreach Ligne [split $Texte "\n"] {
if {[regexp ">" $Ligne]} { set Entete $Ligne ; break }
}
if {[string tolower $Quoi]=="all"} { return $Entete }
regsub ">" $Entete "" Entete
set Access ""
scan $Entete "%s" Access
return $Access
}
proc EnteteDuFichierTFA {Fichier {Quoi "all"}} {
return [EnteteDuTexteTFA [ContenuDuFichier $Fichier] $Quoi]
}
proc QueLaSequenceDuTexteTFA {Texte {MergeTFAs ""}} {
if {$MergeTFAs==""} { set MergeTFAs "FirstOnly" }
if {$MergeTFAs=="MergeTFAs"} { set Merge 1 ; set FirstOnly 0 ; set ListOfTxt 0 }
if {$MergeTFAs=="FirstOnly"} { set Merge 0 ; set FirstOnly 1 ; set ListOfTxt 0 }
if {$MergeTFAs=="ListOfTxt"} { set Merge 0 ; set FirstOnly 0 ; set ListOfTxt 1 }
set LesSequences {}
set Sequence ""
set DejaVuChevron 0
foreach Ligne [split $Texte "\n"] {
if {[regexp ">" $Ligne]} {
if {$Merge} { continue }
if {$FirstOnly && $DejaVuChevron} { return $Sequence }
if {$ListOfTxt && $DejaVuChevron} {
lappend LesSequences $Sequence
set Sequence ""
}
set DejaVuChevron 1
continue
}
regsub -nocase -all -- {[^a-z\*\.\-]} $Ligne "" Ligne
append Sequence $Ligne
}
if { ! $ListOfTxt} { return $Sequence }
lappend LesSequences $Sequence
return $LesSequences
}
proc QueLaSequenceDuAlias {Alias {Rep ""}} {
set Nom [NomDuAlias $Alias]
return [QueLaSequenceDuPAB $Nom $Rep]
}
proc QueLaSequenceDuPAB {Nom {Rep ""}} {
set FichierTFA [GscopeFile $Nom $Rep]
if {[FileAbsent $FichierTFA]} { return "" }
return [QueLaSequenceDuFichierTFA $FichierTFA]
}
proc QueLaSequenceDuTFA {Fichier {MergeTFAs ""}} {
return [QueLaSequenceDuFichierTFA $Fichier $MergeTFAs]
}
proc QueLaSequenceDuFichierTFA {Fichier {MergeTFAs ""}} {
return [QueLaSequenceDuTexteTFA [ContenuDuFichier $Fichier] $MergeTFAs]
}
proc QueLaSequenceDuTexteEMBL Texte {
set TFA [SequenceFormatTFA $Texte "" "embl"]
return [QueLaSequenceDuTexteTFA $TFA]
}
proc QueLaSequenceDuEMBL Fichier {
return [QueLaSequenceDuFichierEMBL $Fichier]
}
proc QueLaSequenceDuFichierEMBL Fichier {
return [QueLaSequenceDuTexteEMBL [ContenuDuFichier $Fichier]]
}
proc CreeFichierTFADuGenomePourBanqueBlast {{FichierACreer ""}} {
global RepertoireDuGenome
global ADN DNA RAC
global NotreOS
global NotreOrga
if { ! [info exists ADN]} { ChargeADNetTDNetRAC }
if {$FichierACreer==""} {
set FichierACreer "$RepertoireDuGenome/tfasdugenome/${NotreOrga}"
}
set Repertoire [file dirname $FichierACreer]
if { ! [file exists $Repertoire]} { File mkdir $Repertoire }
while {[file exists $FichierACreer]} {
if {[OuiOuNon "$FichierACreer already exists. Do I overwrite it ?"]} {
break
} else {
if {[OuiOuNon "Do I cancel ?"]} { return "" }
if {[OuiOuNon "Do I exit ?"]} { exit }
}
}
FaireLire "give the title of the blastdatabase"
set Titre [Entre "$NotreOrga:complete_genome"]
set TFA [SequenceFormatTFA [string range $ADN 1 end] $Titre]
set FichierACreer [Sauve $TFA dans $FichierACreer]
return $FichierACreer
}
proc CreeTroncons {TFAouGCG {FichierACreer ""} {LongueurChevauchement 10000}} {
global RepertoireDuGenome
global ADN DNA RAC
global NotreOS
global NotreOrga
global LongueurTroncons
Wup "LongueurTroncons must be 100000 because Fred's blast databases"
set LongueurTroncons 100000
if {$TFAouGCG=="GCG"} {
set OnVeutGCG 1
set OnVeutTFA 0
}
if {$TFAouGCG=="TFA"} {
set OnVeutGCG 0
set OnVeutTFA 1
}
if {[file exists "$RepertoireDuGenome/beton/adn.pure"]} {
catch {unset ADN}
catch {unset TDN}
catch {unset RAC}
if { ! [info exists ADN]} { ChargeADNetTDNetRAC ".pure" }
set UnsetADN 1
} else {
if { ! [info exists ADN]} { ChargeADNetTDNetRAC }
set UnsetADN 0
}
if {$FichierACreer==""} {
set FichierACreer "$RepertoireDuGenome/tfasdugenome/${NotreOrga}overlap$LongueurChevauchement"
}
set Repertoire [file dirname $FichierACreer]
if { ! [file exists $Repertoire]} { File mkdir $Repertoire }
while {[file exists $FichierACreer]} {
if {[OuiOuNon "$FichierACreer already exists. Do I overwrite it ?"]} {
} else {
if {[OuiOuNon "Do I exit ?"]} { exit }
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
}
set LongueurADN [expr [string length $ADN]-1]
set Titre [Entre ">$NotreOrga:Part_"]
set Debut 1
set Partie 0
while {$Debut < $LongueurADN} {
incr Partie
set Fin [expr $Debut+$LongueurTroncons+$LongueurChevauchement-1]
set BeauPartie [format "%2.2d" $Partie]
set BeauDebut [format "%7.7d" $Debut]
set BeauFin [format "%7.7d" $Fin]
set Entete "$Titre$BeauPartie from base $BeauDebut to $BeauFin"
if {$Fin > $LongueurADN} { set Fin $LongueurADN }
set Bout [BoutADN $Debut $Fin "F"]
set DB 0
set LargeurLigne 50
lappend TFA $Entete
while {$DB < [string length $Bout]} {
lappend TFA [string range $Bout $DB [expr $DB+$LargeurLigne-1]]
incr DB $LargeurLigne
}
incr Debut $LongueurTroncons
}
SauveLesLignes $TFA dans $FichierACreer
if {$OnVeutGCG} {
Wup "I create FicheirACreer.gcg"
File rename "$FichierACreer" "$FichierACreer.tfa"
eval exec fromfasta "$FichierACreer.tfa" -Nucleotide
File delete -force $FichierACreer.tfa
}
if {$UnsetADN} {
catch {unset ADN}
catch {unset TDN}
catch {unset RAC}
}
}
proc CreeLaSequenceDeLaZone K {
global xDebutRectangleDeSelectionNucleique
global yDebutRectangleDeSelectionNucleique
global xFinRectangleDeSelectionNucleique
global yFinRectangleDeSelectionNucleique
if { ! [info exists xDebutRectangleDeSelectionNucleique($K)]} {
FaireLire "Il faut selectionner une zone par <Shift-3>"
return ""
}
if {[regexp "rond" $K]} {
set D [set xDebutRectangleDeSelectionNucleique($K)]
set F [set xFinRectangleDeSelectionNucleique($K)]
set Debut [Mini $D $F]
set Fin [Maxi $D $F]
} else {
set Debut [PositionCanvaOriginaleX $K [Mini \
[set xDebutRectangleDeSelectionNucleique($K)] \
[set xFinRectangleDeSelectionNucleique($K)] \
]]
set Fin [PositionCanvaOriginaleX $K [Maxi \
[set xDebutRectangleDeSelectionNucleique($K)] \
[set xFinRectangleDeSelectionNucleique($K)] \
]]
}
if {[OuiOuNon "I create the nucleic sequence ... Forward ?"]} {
set Orient "F"
} elseif {[OuiOuNon "I create the nucleic sequence ... Reverse ?"]} {
set Orient "R"
} else { FaireLire "I do nothing."; return "" }
set Entete "${Orient}_${Debut}_${Fin}"
set SequenceNuc ">$Entete\n[SequenceFormatBrut [BoutADN $Debut $Fin $Orient]]"
return [AfficheVariable $SequenceNuc "AvecFormateAvecBlaste" $Entete]
}
proc VoisinADNDeLaZone K {
global xDebutRectangleDeSelectionNucleique
global yDebutRectangleDeSelectionNucleique
global xFinRectangleDeSelectionNucleique
global yFinRectangleDeSelectionNucleique
if { ! [info exists xDebutRectangleDeSelectionNucleique($K)]} {
FaireLire "Il faut selectionner une zone par <Shift-3>"
return ""
}
if {[regexp "rond" $K]} {
set D [set xDebutRectangleDeSelectionNucleique($K)]
set F [set xFinRectangleDeSelectionNucleique($K)]
set Debut [Mini $D $F]
set Fin [Maxi $D $F]
} else {
set Debut [PositionCanvaOriginaleX $K [Mini \
[set xDebutRectangleDeSelectionNucleique($K)] \
[set xFinRectangleDeSelectionNucleique($K)] \
]]
set Fin [PositionCanvaOriginaleX $K [Maxi \
[set xDebutRectangleDeSelectionNucleique($K)] \
[set xFinRectangleDeSelectionNucleique($K)] \
]]
}
set Orient "F"
VoisinADN Zone $Debut $Fin $Orient
}
proc Tgbt {} {
set LesInfosGBTags [DecortiqueGBTags OS OC AC gb]
Espionne [FromInfoOfGenBankToEMBL $LesInfosGBTags nuc]
exit
}
proc Tgbk {FichierGBK} {
set LesInfosGenBank [DecortiqueGenBank OS OC SeqADN $FichierGBK]
Espionne [FromInfoOfGenBankToEMBL $LesInfosGenBank ]
}
proc GenBankToEMBL {FichierOuListeOuTexte {FichierEMBL ""}} {
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqADN $FichierOuListeOuTexte]] "\n"]
if {$FichierEMBL!=""} {
SauveLesLignes $LesLignesEMBL dans $FichierEMBL
}
return [join $LesLignesEMBL "\n"]
}
proc FromInfoOfGenBankToEMBL {LesInfosGenBank {OnVeut ""}} {
EspionneL $LesInfosGenBank
Wup "Maybe it will work only if there is ONE gene in the file"
Wup " Otherwise it takes the last"
set Gene ""
set Product ""
set OS "Inconnu inconnu"
set OC "Unknown class"
set Access "Unknown"
foreach Ligne $LesInfosGenBank {
if {[regexp "/Access=" $Ligne]} {
set Access [StringSuivant "/Access=" dans $Ligne]
}
if {[regexp "/OS=" $Ligne]} {
set OS [StringSuivant "/OS=" dans $Ligne]
regsub {\.$} $OS "" OS
}
if {[regexp "/OC=" $Ligne]} {
set OC [StringSuivant "/OC=" dans $Ligne]
}
if {[regexp "/DEFINITION=" $Ligne]} {
set Definition [StringSuivant "/DEFINITION=" dans $Ligne]
set Definition [string trim $Definition]
}
if {[regexp "/DNA=" $Ligne]} {
set SeqNuc [StringSuivant "/DNA=" dans $Ligne]
}
if {[regexp "/translation=" $Ligne]} {
set SeqPro [StringSuivant "/translation=" dans $Ligne]
}
if {[regexp "/gene=" $Ligne]} {
set Gene [StringSuivant "/gene=" dans $Ligne]
}
if {[regexp "/product=" $Ligne]} {
set Product [StringSuivant "/product=" dans $Ligne]
}
if {[regexp "/note=" $Ligne]} {
set Note [StringSuivant "/note=" dans $Ligne]
}
}
if {$Product=="" && [info exists Definition]} { set Product $Definition }
if {$OnVeut=="prot" && ! [info exists SeqPro]} {
if {[info exists SeqNuc] && [regexp -nocase {[^ATGC]} $SeqNuc]} {
set SeqPro $SeqNuc
unset SeqNuc
}
}
if {$OnVeut=="" && [info exists SeqPro] && [info exists SeqNuc]} { set OnVeut "nuc" }
if {$OnVeut=="" && [info exists SeqPro] && ! [info exists SeqNuc]} { set OnVeut "prot" }
if {$OnVeut=="" && ! [info exists SeqPro] && [info exists SeqNuc]} { set OnVeut "nuc" }
if {[info exists SeqPro] && $OnVeut=="prot"} {
set ProtEMBL ""
set LongP [expr [string length $SeqPro]]
append ProtEMBL "ID $Access PRELIMINARY; PRT; $LongP AA."
append ProtEMBL "\nAC $Access"
append ProtEMBL "\nOS $OS."
append ProtEMBL "\nOC $OC"
if {$Product!=""} { append ProtEMBL "\nDE $Product" }
if {$Gene!=""} { append ProtEMBL "\nGN $Gene" }
append ProtEMBL "\nCC -!- taken by Gscope from a GenBank file"
append ProtEMBL "\n[QueSequenceFormatEMBL $SeqPro AvecSQ]"
return $ProtEMBL
}
if {[info exists SeqNuc] && $OnVeut=="nuc"} {
set NucEMBL ""
set LongN [expr [string length $SeqNuc]]
append NucEMBL "ID $Access PRELIMINARY; DNA; $LongN bases."
append NucEMBL "\nAC $Access"
append NucEMBL "\nOS $OS."
append NucEMBL "\nOC $OC"
if {$Product!=""} { append NucEMBL "\nDE $Product" }
if {$Gene!=""} { append NucEMBL "\nGN $Gene" }
append NucEMBL "\nCC -!- taken by Gscope from a GenBank file"
append NucEMBL "\n[QueSequenceFormatEMBL $SeqNuc AvecSQ]"
return $NucEMBL
}
return ""
}
proc WithPDB Nom {
global RepertoireDuGenome
global WithPDB
if {[info exists WithPDB($Nom)]} { return [set WithPDB($Nom)] }
if {[info exists WithPDB]} { return 0 }
set FichierWithPDB "[RepertoireDuGenome]/fiches/withpdb"
if {[file exists $FichierWithPDB]} {
foreach Ligne [LesLignesDuFichier $FichierWithPDB] {
scan $Ligne "%s %d" NomLu nPDB
set WithPDB($NomLu) $nPDB
}
set WithPDB("EstCharge") 1
return [WithPDB $Nom]
}
if { ! [OuiOuNon "Do I count the PDBs in each blast ?"]} {
set WithPDB("EstCharge") 1
return 0
}
set Sortie {}
foreach NomLu [ListeDesPABs] {
set FichierBlast "$RepertoireDuGenome/blastp/$NomLu"
if { ! [file exists $FichierBlast]} { continue }
set nPDB 0
DecortiqueBlast $FichierBlast "" "" Quer lBanqueId lAccess lDE lProfil lPN
foreach BanqueId $lBanqueId] {
if {[EstUnAccessPDB $BanqueId]} { incr nPDB }
}
lappend Sortie "$NomLu $nPDB"
set WithPDB($NomLu) $nPDB
}
SauveLesLignes $Sortie dans $FichierWithPDB
return [WithPDB $Nom]
}
proc TFADuPDB {aPDB {ForceSEQRES ""}} {
#rR attention on fait fastacmd pour avoir les infos et la sequence
global PreviensTFADuPDB
global SequencePDBDansBanqueBlast SequencePDBDansSEQRES
if {[regexp -nocase {^PDB\:} aPDB]} {
regsub -nocase {^PDB\:} $AccessDuPdb "" AccessDuPdb
}
if {[regexp -nocase {[^a-z0-9_]} $aPDB]} {return ""}
set Sequence ""
if {$ForceSEQRES=="ForceSEQRES"} { set ForceSEQRES 1 } else { set ForceSEQRES 0 }
if { !$ForceSEQRES && \
! [info exists SequencePDBDansBanqueBlast] && \
! [info exists SequencePDBDansSEQRES]} {
set SequencePDBDansBanqueBlast 1
}
#rR on met un while pour pouvoir faire break (modifie 20130424)
while { ! $ForceSEQRES && [info exists SequencePDBDansBanqueBlast] && $SequencePDBDansBanqueBlast} {
set AccessDuPdb "PDB:$aPDB"
set TfaDeLaBanqueBlast ""
if {[catch {set TfaDeLaBanqueBlast [exec fastacmd -d /catalog/blast/pdb -s $AccessDuPdb 2> /dev/null]} Message]} {
set TfaDeLaBanqueBlast ""
}
if {$TfaDeLaBanqueBlast==""} {
set AccessDuPdb $aPDB
if {[catch {set TfaDeLaBanqueBlast [exec fastacmd -d /catalog/blast/pdb -s $AccessDuPdb 2> /dev/null]} Message]} {
break
}
}
if {$TfaDeLaBanqueBlast==""} {
set AccessDuPdb "PDB:$aPDB"
if {[catch {set TfaDeLaBanqueBlast [exec fastacmd -d /catalog/blast/pdb -s $AccessDuPdb 2> /dev/null]} Message]} {
break
}
}
set Header [lindex [split $TfaDeLaBanqueBlast "\n"] 0]
regsub -nocase "^.*$aPDB " $Header "" DE
set Sequence [QueLaSequenceDuTexteTFA $TfaDeLaBanqueBlast]
break
}
#rR a mis la sequence=="" et les break ci-dessus (20130424)
if {$Sequence=="" || $ForceSEQRES || ([info exists SequencePDBDansSEQRES] && $SequencePDBDansSEQRES)} {
if { ! [info exists PreviensTFADuPDB]} { set PreviensTFADuPDB 1 }
set JoinCar "|"
set Sequence [TextePDB $aPDB "SEQRES" $JoinCar]
if {$Sequence==""} { return "" }
set DE [TextePDB $aPDB "KEYWDS"]
if { ! [regexp -nocase {_([A-Z]+)} $aPDB Bidon SubUnit]} {
set SubUnit "NoSubUnit"
}
set LesAs {}
foreach Ligne [split $Sequence $JoinCar] {
regsub -nocase {^ *[0-9]+ +[A-Z]* +[0-9]+ +} $Ligne "" Seq3
while {[regexp " " $Seq3]} { regsub -all " " $Seq3 " " Seq3 }
foreach AAA [split $Seq3 " "] {
set A [UT $AAA]
if {($A=="x" || [string length $A]!=1) && $PreviensTFADuPDB} {
FaireLire "I got '$A' translating '$AAA' to one letter in pdb $aPDB\n$Seq3"
if {[OuiOuNon "Do I stop warning ? "]} { set PreviensTFADuPDB 0 }
}
lappend LesAs $A
}
}
set Sequence [join $LesAs ""]
}
if {$Sequence==""} { return "" }
set TFA [SequenceFormatTFA $Sequence "$aPDB $DE" "protbrut"]
return $TFA
}
proc TextePDB {aPDB {Quoi ""} {JoinCar " "} {OnTheWeb ""}} {
if {$Quoi==""} { set Quoi "Ref" }
if {$OnTheWeb eq ""} {set OnTheWeb "OnTheWeb"}
set OnTheWeb [string equal -nocase $OnTheWeb "OnTheWeb"]
regsub -nocase {^PDB[:_]} $aPDB "" aPDB
#rR pour avoir la sequence de SEQRES il faut donner la chaine SEQRES_B.
#rR par defaut on prend la chaine A
set Chain "A"
if {[regexp "SEQRES" $Quoi]} {
if {[regexp {SEQRES_([A-Za-z]+)} $Quoi Match ChaineVoulue]} { set Chain $ChaineVoulue }
set Quoi "SEQRES"
}
if { ! [regexp "/" $aPDB]} {
regsub -nocase {_[a-z]*} $aPDB "" aPDB
set RepLocalPDB "[RepertoireDuGenome]/localpdb"
set FichierLocalPDB "$RepLocalPDB/pdb[string tolower $aPDB].ent"
if {[file exists $FichierLocalPDB]} {
set TextePDB [ContenuDuFichier $FichierLocalPDB]
} else {
set aPDB [string tolower $aPDB]
set SousRep [string range $aPDB 1 2]
#lm Local PDB directories
set FichierPDB "/commun/banbi/pdb/compressed_files/$SousRep/pdb$aPDB.ent.gz"
if {[file exists $FichierPDB]} {
set TextePDB [exec zcat $FichierPDB]
} else {
if {! $OnTheWeb} {
return ""
}
#lm ne passe plus par RecupereUnFichierSurWeb...
#lm prend cas general
set pdbid [string toupper $aPDB]
#lm change adresse de la PDB
#lm voir https://www.rcsb.org/pdb/static.do?p=download/http/index.html
set url "https://files.rcsb.org/download/XXXX.pdb"
set url [string map [list "XXXX" "$pdbid"] $url]
#lm use tclcurl
package require TclCurl
::curl::transfer -url $url -followlocation 1 -bodyvar TextePDB
}
}
} else {
set TextePDB [ContenuDuFichier $aPDB]
}
if {[string equal -nocase "All" $Quoi]} { return $TextePDB }
if {$TextePDB==""} { return "" }
#lm ultime test pour savoir si on a bien un PDB #rR ................... supprime par rR 2016/09/14
if {0 && [string range $TextePDB 0 5] ne "HEADER"} {
return ""
}
set JusquASeqres 0
set JusquAAtom 1
if {$Quoi=="Ref" && $JusquASeqres} {
set iSEQRES [string first "\nSEQRES " $TextePDB]
if {$iSEQRES<0} { set iSEQRES end }
return [string range $TextePDB 0 $iSEQRES]
}
if {$Quoi=="Ref" && $JusquAAtom} {
set iATOM [string first "\nATOM " $TextePDB]
if {$iATOM<0} { set iATOM end }
return [string range $TextePDB 0 $iATOM]
}
if {$Quoi!=""} {
set Sortie {}
foreach Ligne [split $TextePDB "\n"] {
if { ! [regexp "^$Quoi" $Ligne]} { continue }
if {$Quoi=="SEQRES"} {
scan $Ligne "%s %s %s %s" K I C N
if {$K!="SEQRES"} { break }
if {$Chain!=$C} { continue }
regsub "$K *$I *$C *$N" $Ligne "" CodesTroisLettres
lappend Sortie $CodesTroisLettres
continue
}
set Ligne [string range $Ligne 0 69]
regsub "$Quoi" $Ligne "" Ligne
set Ligne [string trim $Ligne]
lappend Sortie $Ligne
if {$Quoi!="ATOM" && [regexp "^ATOM" $Ligne]} { break }
}
if {$Quoi=="SEQRES"} {
set Sortie [join $Sortie " "]
regsub -all { +} $Sortie " " Sortie
return [string trim $Sortie]
}
return [join $Sortie $JoinCar]
}
return $TextePDB
}
proc MoleculeDuPDB aPDB {
set Chaine ""
set AttendreLaBonneChaine [regexp -nocase {_([A-Z]+)} $aPDB Bidon Chaine]
set TextePDB [TextePDB $aPDB "COMPND" "\n"]
if {$TextePDB==""} { return "" }
set Molecule ""
foreach Ligne [split $TextePDB "\n"] {
if {[regexp -nocase "MOLECULE:" $Ligne]} {
set Molecule [StringSuivant "MOLECULE: " dans $Ligne]
regsub {;} $Molecule "" Molecule
if {$AttendreLaBonneChaine} { continue }
return $Molecule
}
if {[regexp -nocase "CHAIN:" $Ligne]} {
set Chaines [StringSuivant "CHAIN: " dans $Ligne]
if {[regexp $Chaine $Chaines]} { return $Molecule }
set Molecule ""
}
}
return ""
}
proc OrganismeDuPDB TexteOuAccessPDB {
set TextePDB [TextePDB $TexteOuAccessPDB "SOURCE" "\n"]
if {$TextePDB==""} { return [Glossaire "Inconnu inconnu" Complet] }
set Organisme "Inconnu inconnu"
Wup "It can be (GENUS SPECIES)"
if {[regexp -nocase {^\(([A-Z]+ [A-Z]+)\)$} $TextePDB Match GenreEspece]} {
set Organisme [OrganismeCanonique $GenreEspece "NonStricte"]
return $Organisme
}
Wup "Or behind ORGANISM_SCIENTIFIC:"
foreach Ligne [split $TextePDB "\n"] {
if { ! [regexp -nocase "ORGANISM_SCIENTIFIC:" $Ligne]} { continue }
set Organisme [StringSuivant "ORGANISM_SCIENTIFIC:" dans $Ligne]
set Organisme [OrganismeCanonique $Organisme "NonStricte"]
break
}
return $Organisme
}
proc EMBLdeGscope {Access {ACFirst ""}} {
if {$ACFirst=="ACFirst"} { set ACFirst 1 } else { set ACFirst 0 }
if {[regexp {[\:_]} $Access Car]} {
set Nom [StringApres $Car dans $Access]
} else {
set Nom $Access
}
set G [GenomeDu $Nom]
if {$G==""} {return ""}
set FicEmbl "$G/protembl/$Nom"
if { ! [file exists $FicEmbl]} { return "" }
if { ! $ACFirst} { return [ContenuDuFichier $FicEmbl] }
set LigneAC ""
set LesLignesEmblSansAC {}
foreach Ligne [LesLignesDuFichier $FicEmbl] {
if {[regexp "^AC " $Ligne]} {
set LigneAC $Ligne
continue
}
lappend LesLignesEmblSansAC $Ligne
}
if {$LigneAC==""} {
FaireLire "I can't find a line 'AC something' in $FicEmbl"
}
return "$LigneAC\n[join $LesLignesEmblSansAC "\n"]"
}
proc EstUnAccessDUneBanqueBlastPDeGscope Access {
if {[regexp -nocase {[A-Z]+AllProt[\:_]} $Access]} { return 1 }
return 0
}
proc EnlevePrefixeBank {l} {
if {! [info exists ::Defauts] || ! [set ::Defauts(RemoveBankPrefix)]} {return $l}
set l [string map [list ">" "" "lcl|" ""] $l]
set ul [string toupper $l]
set s [string index $l 0]
if {$s ne ">"} {
set s ""
}
set done 0
foreach b [set ::Defauts(PrefixesBank)] {
set ub [string toupper $b]
#lm Attention !
#lm enleve "_" comme separateur de prefixe car peut
#lm poser des probleme avec access swissprot !
#
#lm longueur du pattern
set d [expr {[string length $s]+[string length $ub] +1}]
foreach t {"\\\|" "\\\:"} {
set m "${s}${ub}${t}"
if {[regexp -nocase "^$m" $ul]} {
if {$ub ne "PDB" && [regexp -nocase {[a-z]} [string index $ul $d]]} {
set l [string range $l $d end]
set done 1
break
}
}
}
if {$done} {
break
}
}
return $l
}
proc EstUnAccessPDB {Access} {
if {[regexp -nocase {^PDB(\||\:|_[0-9])} $Access ]} { return 1 }
set Access [EnlevePrefixeBank $Access]
#lm On fait au plus strict
#lm Un access PDB ne peut pas etre plus long que
#lm 6 caracteres : XXXX_X
if {[string length $Access] > 6} {return 0}
if { ! [regexp -nocase {^[0-9][a-z0-9]{3}($|_$|_.$|_..$)} $Access] } { return 0 }
if { [regexp -nocase {_[0-9a-z]{3,}} $Access] } { return 0 }
return 1
}
proc AffichePDB aPDB {
regsub "PDB_" $aPDB "" aPDB ; #rR 2017/10/07
JeMeSignale
set TextePDB [TextePDB $aPDB "Ref"]
if {$TextePDB==""} { return "" }
return [AfficheVariable $TextePDB "AvecPDB"]
}
proc HistogrammeDuNombreDesHomologues {{Type "homo"}} {
foreach Nom [ListeDesPABs] {
lappend LaListe [NombreDeHomologues $Nom $Type]
}
Histogramme $LaListe
}
proc LesBornesAvecLesNucEMBL {} {
global RepertoireDuGenome
global ListeDesPABs
if {[file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} {
if {[OuiOuNon "$RepertoireDuGenome/fiches/bornesdespabs \n exists. Do I cancel ?"]} { return "" }
}
foreach Fichier [glob "$RepertoireDuGenome/nucembl/*"] {
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp "^AC" $Ligne]} {
scan $Ligne "%s %s" AC Nom
continue
}
if {[regexp "CC \-\!\- from" $Ligne]} {
scan $Ligne "%s %s %s %d %s %d%s %s %s" CC XXX FROM Debut TO Fin POINT ORIENTATION Orient
lappend LesBornes "$Nom $Debut $Fin $Orient"
break
}
}
Espionne "$Nom $Debut $Fin $Orient"
}
return [SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs"]
}
proc OrgaDuFetcheAccess Access {
global AccessDejaVus OrgaDejaVus
if { ! [info exists AccessDejaVus]} { set AccessDejaVus {} }
if {[regexp ":" $Access]} {
set Orga [OrganismeDeLaLigneTBlastN $Access]
if { $Orga != "Inconnu inconnu"} { return $Orga }
}
set Ind [lsearch -exact $AccessDejaVus $Access]
if { $Ind == -1 } {
foreach Ligne [split [Fetche $Access] "\n"] {
if [regexp "^OS" $Ligne] {
set lili [split [string trim [string range $Ligne 2 end]] " "]
set Genre [lindex $lili 0]
regsub {[^A-Za-z]} [lindex $lili 1] "" Espece
set Organisme "$Genre $Espece"
break
}
}
if {[info exists Organisme]} {
set Orga [Glossaire $Organisme Court]
} else {
set Orga "Inconnu"
}
lappend AccessDejaVus $Access
lappend OrgaDejaVus $Orga
return $Orga
} else {
return [lindex $OrgaDejaVus $Ind]
}
}
proc LaSequenceDesLignesEMBL LesEMBL {
Wup "Return the sequence of the EMBL text"
set OK 0
set Sequence ""
foreach Ligne $LesEMBL {
if {[regexp "^SQ" $Ligne]} {
set OK 1
continue
}
if {$OK} {
regsub -all -nocase {[^A-Z]} $Ligne "" BoutDeSeq
append Sequence $BoutDeSeq
}
}
return $Sequence
}
proc LaSequenceDuFichierEMBL Fichier {
return [LaSequenceDesLignesEMBL [LesLignesDuFichier $Fichier]]
}
proc LaSequenceDuTexteEMBL Texte {
return [LaSequenceDesLignesEMBL [split $Texte "\n"]]
}
proc CompareLesSequencesDesAccess {A B} {
Wup "Return 1 if the sequences of Access A and B are the same"
set SeqA [LaSequenceDesLignesEMBL [LaSequenceDesBanques $A $A a "OnVeutEMBL"]]
set SeqB [LaSequenceDesLignesEMBL [LaSequenceDesBanques $B $B b "OnVeutEMBL"]]
return [string equal -nocase $SeqA $SeqB]
}
proc LesOrgaDistAccessDesOrthologues Nom {
global RepertoireDuGenome
global LesOrgaDistAccessDesOrthologues
global NotreOrga
if {[info exists LesOrgaDistAccessDesOrthologues($Nom)]} {
return [set LesOrgaDistAccessDesOrthologues($Nom)]
}
if {[info exists LesOrgaDistAccessDesOrthologues]} { return {} }
set FichierDistancesPhylo "$RepertoireDuGenome/fiches/distancesphylo.$NotreOrga"
if { ! [file exists $FichierDistancesPhylo]} { return {} }
foreach Ligne [LesLignesDuFichier $FichierDistancesPhylo] {
set Liste [split $Ligne " "]
set NomLu [lindex $Liste 0]
set LesOrgaDistAccessDesOrthologues($NomLu) [lrange $Liste 1 end]
}
if {[info exists LesOrgaDistAccessDesOrthologues($Nom)]} {
return [set LesOrgaDistAccessDesOrthologues($Nom)]
}
return {}
}
proc VerifDesCopains {} {
global RepertoireDuGenome
global NotreOS
foreach Nom [ListeDesPABs] {
set FichierDesCops "$RepertoireDuGenome/tfasdescopains/$Nom"
if { ! [file exists $FichierDesCops]} { continue }
set n 0
set LesPositions {}
foreach Ligne [LesLignesDuFichier $FichierDesCops] {
if { ! [regexp "^>" $Ligne]} { continue }
incr n
if {[regexp "OS\:$NotreOS" $Ligne]} { lappend LesPositions [format "%3d" $n] }
}
if {$n<40} { continue }
Espionne "$Nom $n [join $LesPositions " "]"
}
}
proc TestConcatLesTFAs {} {
# set Selection "EST:[StringSuivant "EST:" dans [ContenuDuFichier ~/sele]]"
set Selection [ContenuDuFichier "[HomeRipp]/SelectionBOX006.txt"]
return [ConcatLesTFAs $Selection]
}
proc ConcatLesTFAs {Selection {ButNo "ButNo:"}} {
global RepertoireDuGenome
set ListeDesAccessARetirer [lrange [split $ButNo ":"] 1 end]
set Force 1
set Cool 0
set LesTFAsConcatenes {}
set LesBanqueIdRestants {}
set LesAccessRestants {}
set LesPNs {}
set LesOXs {}
foreach Ligne [split $Selection "\n"] {
Espionne "Concat de $Ligne"
if { ! [regexp -nocase {[A-Z]} $Ligne]} { continue }
set Access ""
set PN 0.001
set OX "Inconnu inconnu"
scan $Ligne "%s %s %s %s" BanqueId Access PN OX
if {[regexp {\|} $BanqueId]} {
lassign [split $BanqueId "|"] B A I
set BanqueId $I
set Access $A
}
if {$Access==""} { set Access $BanqueId }
if {[lsearch -exact $ListeDesAccessARetirer $Access] > -1} { continue }
if {[EstUnAccessPDB $BanqueId]} {
set AccessOK $BanqueId
if {[info exists DejaVu($AccessOK)]} { continue }
set DejaVu($AccessOK) 1
Wup "First we search in /catalog/blast/pdb if not in pdb.fasta"
set FiPdb "/catalog/blast/pdb"
if {[FileAbsent $FiPdb] && [FileExists "$FiPdb.fasta"]} { set FiPdb "$FiPdb.fasta" }
if {[FileAbsent $FiPdb]} { continue }
set TFA [LaSequenceDuTFAs $FiPdb $BanqueId "" "" "ForceAccessFirst"]
if {$TFA!=""} {
lappend LesTFAsConcatenes $TFA
continue
}
Wup "Then we search in pdb itself"
set TFA [TFADuPDB $BanqueId]
if {$TFA!=""} {
lappend LesTFAsConcatenes $TFA
continue
}
Warne "$Ligne\n not found in pdb"
continue
}
lappend LesBanqueIdRestants $BanqueId
lappend LesAccessRestants $Access
lappend LesPNs $PN
lappend LesOXs $OX
}
if { ! [PrepareLesSequencesDesBanques "YaQuelqun"]} {
PrepareLesSequencesDesBanques $LesBanqueIdRestants $LesAccessRestants
}
foreach BanqueId $LesBanqueIdRestants Access $LesAccessRestants PN $LesPNs OX $LesOXs {
set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
Espionne "$BanqueId $Access AccessOK=$AccessOK [llength $LesLignesEMBL] lignes dans l'EMBL"
if {[llength $LesLignesEMBL] < 5} { Warne "$BanqueId $Access introuvable\n=$LesLignesEMBL=" ; continue }
if {[info exists DejaVu($AccessOK)]} { continue }
set DejaVu($AccessOK) 1
set Descriptif [LeDescriptif $AccessOK] ;#rR fait dans LesDescriptifsDuBlast
Espionne "Descriptif avec $AccessOK : $Descriptif"
if {[regexp "no description" $Descriptif]} { set Descriptif "" }
#rR set TFA [SequenceFormatTFA [join $LesLignesEMBL "\n"] $Descriptif "embl"]
set Entete ""
if {$AccessOK!=""} { set Entete "$AccessOK $Descriptif" }
if {[UseBanqueIdForDbClustal]} {
if {[regexp -nocase {^[a-z0-9]+_[a-z0-9]+$} $BanqueId]} {
set Entete "$BanqueId $Descriptif $AccessOK"
}
}
set TFA [SequenceFormatTFA [join $LesLignesEMBL "\n"] $Entete "embl"]
if {[OnVireLesMonstresLointains]} {
set ExpectMonstresLointains 0.001
set LongueurMonstresLointains 3000
set Long [string length [QueLaSequenceDuTexteTFA $TFA]]
if {$PN>$ExpectMonstresLointains && $Long>$LongueurMonstresLointains \
|| [expr $Long>($LongueurMonstresLointains*3)]} {
Warne "Je vire le monstre lointain $BanqueId Access"
continue
}
}
lappend LesTFAsConcatenes $TFA
}
return [join $LesTFAsConcatenes "\n"]
}
proc UseBanqueIdForDbClustal {{Value ""}} {
global UseBanqueIdForDbClustal
if {$Value!=""} { set UseBanqueIdForDbClustal $Value }
if { ! [info exists UseBanqueIdForDbClustal]} { set UseBanqueIdForDbClustal 0 }
return $UseBanqueIdForDbClustal
}
proc CreeTousLesTFAsDesMSFs {{Liste ""} {AvecGap ""} {SousRep ""}} {
global RepertoireDuGenome
set RepTfas "[RepertoireDuGenome]/$SousRep"
if {$SousRep==""} {
set SousRep "tfas"
set Ask 1
} else {
set Ask 0
}
while {$Ask} {
set RepTfas "[RepertoireDuGenome]/$SousRep"
if {[OuiOuNon "Do I store the tfas files in $RepTfas"]} { break }
set RepTfas [Entre $RepTfas]
if {$RepTfas=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
}
if { ! [file exists $RepTfas]} { file mkdir $RepTfas }
if {$Liste==""} {
set Liste [ListeDesPABs]
}
foreach Nom $Liste {
Espionne $Nom
set FichierMSF "$RepertoireDuGenome/msf/$Nom"
if { ! [file exists $FichierMSF]} { continue }
set FichierTFA "$RepTfas/$Nom"
if {[file exists $FichierTFA]} { continue }
Espionne [SauveLesLignes [CreeLeTFAsDuMSF $FichierMSF $AvecGap] dans $FichierTFA]
}
}
proc CreeLesFichiersPIClustalwEtPSClustalw {{OrgaDeReference ""} {Extension ""}} {
global RepertoireDuGenome
global NotreOS
global NotreOrga
global PiPsWaitsForTheMSF
if { ! [info exists PiPsWaitsForTheMSF]} { set PiPsWaitsForTheMSF 0 }
set PourParalogues [string equal $Extension ".paralogues"]
if {$OrgaDeReference==""} {
set OrgaDeReference $NotreOrga
}
if {$Extension==""} {
set Extension ".$OrgaDeReference"
}
if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
set Source "$RepertoireDuGenome/msf"
if {$Extension==".$NotreOrga"} {
set Source "$RepertoireDuGenome/msf"
}
if {$PourParalogues} {
set Source "$RepertoireDuGenome/msfparalogues"
}
set DestinPI "$RepertoireDuGenome/fiches/piclustalw$Extension"
set DestinPS "$RepertoireDuGenome/fiches/psclustalw$Extension"
if {[file exists $DestinPI]} {
if {[OuiOuNon "Do I keep the existing file $DestinPI ?"]} {
foreach Ligne [LesLignesDuFichier $DestinPI] {
scan $Ligne "%s" Nom
set DejaVuPI($Nom) 1
}
} else {
File delete $DestinPI
}
}
if {[file exists $DestinPS]} {
if {[OuiOuNon "Do I keep the existing file $DestinPS ?"]} {
foreach Ligne [LesLignesDuFichier $DestinPS] {
scan $Ligne "%s" Nom
set DejaVuPS($Nom) 1
}
} else {
File delete $DestinPS
}
}
foreach Nom [ListeDesPABs] {
LeDescriptif PourQuIlSoitCharge $Nom
set Fichier "$Source/$Nom"
if { ! [file exists $Fichier] && $PiPsWaitsForTheMSF } { after 120000 }
if { ! [file exists $Fichier]} { continue }
if {[regexp "NoSequence" [PremiereLigneDuFichier $Fichier]]} { continue }
if {[info exists DejaVuPI($Nom)] && [info exists DejaVuPS($Nom)]} { continue }
set LesAPIPSs [IdentiteEtSimilariteDansMSF $Fichier $OrgaDeReference]
set LesOPIs {}
set LesOPSs {}
set LesAccess {}
foreach AccessPIPS $LesAPIPSs {
scan $AccessPIPS "%s %f %f" Access PI PS
if {[YaPABenDebutDe $Access]} {
set OrgaDuAccess($Access) $NotreOrga
continue
}
lappend LesAccess $Access
}
foreach AccessOrga [LesOrgasDesAccess $LesAccess Court $Nom] {
scan $AccessOrga "%s %s" Access Orga
set OrgaDuAccess($Access) $Orga
}
foreach AccessPIPS $LesAPIPSs {
scan $AccessPIPS "%s %f %f" Access PI PS
if {[info exists OrgaDuAccess($Access)]} {
set Orga [set OrgaDuAccess($Access)]
} elseif {[regexp "^PAB|^ABY|^PYAB" $Access]} {
set Orga "paby"
} elseif {[regexp "^PFOK|^PFUR" $Access]} {
set Orga "pfur"
} elseif {[regexp "^PAE:" $Access]} {
set Orga "pae"
} else {
set Orga [OrgaDuAccess $Access Court]
}
if {$PourParalogues} {
if {[YaPABenDebutDe $Access]} {
set PAB $Access
} else {
set PAB [Narcisse $Access]
}
lappend LesOPIs "$PAB $PI"
lappend LesOPSs "$PAB $PS"
} else {
foreach O [SplitOrgas $Orga] {
lappend LesOPIs "$O $PI"
lappend LesOPSs "$O $PS"
}
}
}
set LesOPIsTries [lsort -decreasing -command CompareLesFloats $LesOPIs]
set LesOPSsTries [lsort -decreasing -command CompareLesFloats $LesOPSs]
set TextePI "$Nom [join $LesOPIsTries " "]"
set TextePS "$Nom [join $LesOPSsTries " "]"
if { ! [info exists DejaVuPI($Nom)]} {
AppendAuFichier $DestinPI $TextePI
}
if { ! [info exists DejaVuPS($Nom)]} {
AppendAuFichier $DestinPS $TextePS
}
}
}
proc IdentiteEtSimilariteDansMSF {FichierMSF {OrgaDeReference ""}} {
global RepertoireDuGenome
global MatriceDeSimilarite
global NotreOS
global NotreOrga
if { ! [info exists MatriceDeSimilarite] } {
set OnAttendPP 1
set FichierSimilariteDefaut "[GscopeEtc]/gscope_similarite"
set FichierSimilarite "[RepertoireDuGenome]/fiches/similarite"
if { ! [file exists $FichierSimilarite]} {
set FichierSimilarite $FichierSimilariteDefaut
}
foreach Ligne [LesLignesDuFichier $FichierSimilarite] {
if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
if {[regexp {\.\.} $Ligne]} {
regsub {\.\.} $Ligne "" Ligne
while {[regexp " " $Ligne ]} { regsub -all " " $Ligne " " Ligne }
set LesAAs [split [string trim $Ligne] " "]
set LesAAsRestants $LesAAs
set OnAttendPP 0
continue
}
if {$OnAttendPP} { continue }
set Ligne [string toupper $Ligne]
set AACourant [lindex $LesAAsRestants 0]
while {[regexp " " $Ligne ]} { regsub -all " " $Ligne " " Ligne }
set nRestants [llength $LesAAsRestants]
set LesScores [lrange [split [string trim $Ligne] " "] 0 [incr nRestants -1]]
foreach AA $LesAAsRestants Score $LesScores {
set MatriceDeSimilarite($AACourant,$AA) $Score
set MatriceDeSimilarite($AA,$AACourant) $Score
}
set LesAAsRestants [lrange $LesAAsRestants 1 end]
}
foreach AA $LesAAs {
set Ligne ""
foreach BB $LesAAs {
append Ligne " [format "%4.1f" [set MatriceDeSimilarite($AA,$BB)]]"
}
}
}
if {$OrgaDeReference==""} { set OrgaDeReference $NotreOrga }
set Nom [file tail $FichierMSF]
set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre Sequences]
if {$NombreDeSequences<2} { return {} }
set MaxLongueurSequence [string length [set Sequences([lindex $LesSequencesDansLOrdre 0])]]
if {$OrgaDeReference == "QueryInFirstPlace"} {
set SeqPAB $Sequences([lindex $LesSequencesDansLOrdre 0])
} elseif {$OrgaDeReference == $NotreOrga} {
if { ! [info exists Sequences($Nom)]} { return {} }
set SeqPAB [set Sequences($Nom)]
} else {
set iOrgaRef [lsearch -regexp $LesSequencesDansLOrdre $OrgaDeReference]
if {$iOrgaRef < 0} { return {} }
set SeqPAB [set Sequences([lindex $LesSequencesDansLOrdre $iOrgaRef])]
}
set lSeqPAB [string length $SeqPAB]
foreach NomSeq $LesSequencesDansLOrdre {
set Seq [string toupper [set Sequences($NomSeq)]]
set lSeq [string length $Seq]
set CumulScore 0
set nCumulScore 0
set CumulId 0
set nCumulId 0
set Commun ""
set LongVraiePAB 0
set LongVraieSeq 0
set nLesDeuxSansPoints 0
set nAuMoinsUnSansPoint 0
set PS_LongVraiePAB 0
set PS_LongVraieSeq 0
set PS_nLesDeuxSansPoints 0
set PS_nAuMoinsUnSansPoint 0
for {set i 0} {$i<$lSeqPAB} {incr i} {
if {$i >= $lSeq} { break }
set AA [string range $SeqPAB $i $i]
set BB [string range $Seq $i $i]
if { $AA!="." } { incr LongVraiePAB }
if { $BB!="." } { incr LongVraieSeq }
if { $AA!="." && $BB!="." } { incr nLesDeuxSansPoints }
if { $AA!="." || $BB!="." } { incr nAuMoinsUnSansPoint }
if { $AA!="." && $AA==$BB } { incr CumulId }
if {[info exists MatriceDeSimilarite($AA,$BB)]} {
if { $AA!="." } { incr PS_LongVraiePAB }
if { $BB!="." } { incr PS_LongVraieSeq }
if { $AA!="." && $BB!="." } { incr PS_nLesDeuxSansPoints }
if { $AA!="." || $BB!="." } { incr PS_nAuMoinsUnSansPoint }
set Score [set MatriceDeSimilarite($AA,$BB)]
set CumulScore [expr $CumulScore + $Score]
}
}
set PI($NomSeq) [expr $CumulId*100/[Maxi 1 $nLesDeuxSansPoints]]
# set PI($NomSeq) [expr $CumulId*100/[Maxi 1 $nAuMoinsUnSansPoint]
# set PI($NomSeq) [expr $CumulId*100/[Maxi 1 [Mini $LongVraiePAB $LongVraieSeq]]]
set PS($NomSeq) [expr $CumulScore*1.0/[Maxi 1 $PS_nLesDeuxSansPoints]]
# set PS($NomSeq) [expr $CumulScore*1.0/[Maxi 1 $PS_nAuMoinsUnSansPoint]
# set PS($NomSeq) [expr $CumulScore*1.0/[Maxi 1 [Mini $PS_LongVraiePAB $PS_LongVraieSeq]]]
lappend LesPIs "$NomSeq [format "%6.3f" [set PI($NomSeq)]]"
lappend LesPSs "$NomSeq [format "%6.3f" [set PS($NomSeq)]]"
lappend LesPIPSs "$NomSeq [format "%6.3f" [set PI($NomSeq)]] [format "%6.3f" [set PS($NomSeq)]]"
}
Wup "Choisir le bon .................!!!! "
return $LesPIPSs
return $LesPIs
return $LesPSs
}
proc CreeLesDescriptifsAvecLeMSFPourTous {{Rep ""}} {
global RepertoireDuGenome
if { $Rep=="" } { set Rep "$RepertoireDuGenome/msf" }
if { ! [file exists $Rep]} { set Rep "$RepertoireDuGenome/$Rep" }
if { ! [file exists $Rep]} {
FaireLire "Sorry, directory $Rep not found"
return ""
}
foreach Nom [ListeDesPABs] {
set FichierMSF "$Rep/$Nom"
if { ! [file exists $FichierMSF]} { continue }
CreeLesDescriptifsAvecLeMSF $FichierMSF $Nom
}
}
proc CreeLesDescriptifsAvecLeMSF {FichierMSF {PourQui ""}} {
DecortiqueUnMSF $FichierMSF LesAccess
return [CreeLesDescriptifsAvecLesAccess $LesAccess $PourQui]
}
proc CreeLesDescriptifsAvecLeBlastPourTous {{Rep ""} {Keep ""} {SeuilExpect ""} {MaxListe ""}} {
TaxClass 9606 ;#rR pour le charger !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if {$Keep==""} { set Keep "Keep" }
if {$Keep=="Keep"} { set Keep 1 } else { set Keep 0 }
if { $Rep=="" } { set Rep "[RepertoireDuGenome]/blastp" }
if { ! [file exists $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
if { ! [file exists $Rep]} {
FaireLire "Sorry, directory $Rep not found"
return ""
}
set Dest "[RepertoireDuGenome]/descriptifs"
if { ! [file exists $Dest]} { file mkdir $Dest }
foreach Nom [ListeDesPABs] {
set FichierDescr "$Dest/$Nom"
if { $Keep && [file exists $FichierDescr]} { continue }
set FichierBlast "$Rep/$Nom"
if { ! [file exists $FichierBlast]} { continue }
if {[PasTouche $Nom]} {continue}
set LeDescr [CreeLesDescriptifsAvecLeBlast $FichierBlast $Nom]
FinPasTouche $Nom
}
}
proc CreeLesDescriptifsAvecLeBlast {FichierBlast {PourQui ""} {SeuilExpect ""} {MaxListe ""}} {
if {$SeuilExpect==""} { set SeuilExpect "SansSeuilExpect" }
DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query lBanqueId lAccess lDE lProfil lPN
return [CreeLesDescriptifsAvecLesAccess $lAccess $PourQui $lBanqueId]
}
proc CreeLesDescriptifsAvecLeProfileSearch {FichierPFS {PourQui ""}} {
if {$PourQui==""} { set PourQui "list" }
set OnAttend 1
set lBanqueId {}
set lAccess {}
foreach Ligne [LesLignesDuFichier $FichierPFS] {
if {$OnAttend} {
if { ! [regexp {Sequence +Strd +ZScore +Orig +Length} $Ligne]} { continue }
set OnAttend 0
continue
}
scan $Ligne "%s %s %s %s %s %s %s" BId Strand ZScore Orig Length PEx Access
Espionne "$BId $Access"
lappend lBanqueId $BId
lappend lAccess $Access
}
return [CreeLesDescriptifsAvecLesAccess $lAccess $PourQui $lBanqueId]
}
proc CreeLesDescriptifsAvecLesAccess {lAccess {PourQui ""} {lBanqueId ""}} {
global PABCourant
set PABCourant $PourQui
Wup "Attention if lBanqueId exists it's better. But we use Access as reference"
if {$lBanqueId=={}} {
set lBanqueId $lAccess
}
Wup "PourQui can be PABxxx or window_ or itself"
Wup "PourQui can also be file_NAMEOFTHEFILETOCREATE"
if {[regexp "^window_?" $PourQui]} {
set PourWindow 1
set LaListe {}
set PourQui "itself_"
}
if {[regexp "^list_?" $PourQui]} {
set PourListe 1
set LaListe {}
set PourQui "itself_"
}
if {[regexp "^append_?" $PourQui]} {
set PourAppend 1
set FichDesc [StringApres "_" dans $PourQui]
}
PrepareLesSequencesDesBanques $lBanqueId $lAccess
foreach BanqueId $lBanqueId Access $lAccess {
Espionne "$BanqueId $Access"
set LesLignesEMBL [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"]
if {$LesLignesEMBL=={}} { continue }
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
regsub -all {\:} $DE "_" DE
set Descriptif "$AccessOK OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX"
set Retour [StockeLeDescriptif $AccessOK $Descriptif $PourQui]
if {[info exists PourAppend]} { AppendAuFichier $FichDesc $Descriptif }
if {$PourQui=="itself_"} { lappend LaListe $Retour }
}
if {[info exists PourWindow]} {
return [AfficheVariable [join $LaListe "\n"] "GrandeLargeur"]
}
if {[info exists PourListe]} {
return $LaListe
}
unset PABCourant
}
proc CreeLesDescriptifsPourTous {{Liste ""}} {
#rR 2015/11/08 c'est assez confus ... jusqu'à 2015/11/08 on faisait AvecLesCandidatsPouClustalW ...
#rR je pense les avec les blast c'est mieux ...
return [CreeLesDescriptifsAvecLeBlastPourTous]
# return [CreeLesDescriptifs_AvecLesCandidatsPouClustalW_PourTous $Liste]
}
proc CreeLesDescriptifs_AvecLesCandidatsPouClustalW_PourTous {{Liste ""}} {
global LesLignesEMBLEnMemoire
global AccessOKEnMemoire
if {$Liste==""} { set Liste [ListeDesPABs] }
foreach Nom $Liste {
set FichierDescriptif [GscopeFile $Nom "descriptifs"]
if {[file exists $FichierDescriptif} { continue }
if {[PasTouche $Nom]} { continue }
Espionne "Creation du descriptif AvecLesCandidatsPouClustalW pour $Nom"
if {[info exists LesLignesEMBLEnMemoire]} { unset LesLignesEMBLEnMemoire }
if {[info exists AccessOKEnMemoire]} { unset AccessOKEnMemoire }
LesCandidatsPourClustalW $Nom
FinPasTouche $Nom
}
}
proc CreeTFADeTousLesPABs {} {
global RepertoireDuGenome
set FichierTFAs "$RepertoireDuGenome/db/proteines.tfa"
if {[file exists $FichierTFAs]} {
if {[OuiOuNon "$FichierTFAs\n already exists. Do I replace it ?"]} {
File delete $FichierTFAs
} else {
return $FichierTFAs
}
}
set Rep [file dirname $FichierTFAs]
if { ! [file exists $Rep]} { File mkdir $Rep }
foreach Nom [ListeDesPABs] {
set SeqPro [ContenuDuFichier "$RepertoireDuGenome/prottfa/$Nom"]
set BanqueId "[string toupper [PreFixe]]:$Nom"
regsub {^>} $SeqPro ">$BanqueId " SeqPro
AppendAuFichier $FichierTFAs $SeqPro
}
return $FichierTFAs
}
proc CreeLesPABsAvecGenBank {{Fichier ""}} {
global RepertoireDuGenome
global NotreOS
global NotreOC
global NePasPrevenirPourGenBank
set Previens 1
if {[info exists NePasPrevenirPourGenBank] && $NePasPrevenirPourGenBank} {
set Previens 0
}
set FichierAttention "$RepertoireDuGenome/fiches/attention_genbank"
if { ! [info exists "$RepertoireDuGenome/infos"]} {
File mkdir "$RepertoireDuGenome/infos"
}
if { ! [info exists "$RepertoireDuGenome/prottfa"]} {
File mkdir "$RepertoireDuGenome/prottfa"
}
if { ! [info exists "$RepertoireDuGenome/protembl"]} {
File mkdir "$RepertoireDuGenome/protembl"
}
if { ! [info exists "$RepertoireDuGenome/nuctfa"]} {
File mkdir "$RepertoireDuGenome/nuctfa"
}
if { ! [info exists "$RepertoireDuGenome/nucembl"]} {
File mkdir "$RepertoireDuGenome/nucembl"
}
if {$Fichier==""} {
FaireLire "Please browse for the Protein file created by GenBank"
set Fichier [ButineArborescence All $RepertoireDuGenome/]
if {$Fichier==""} { return 0 }
}
set OldNom ""
set Keep 0
if {[llength [glob -nocomplain "$RepertoireDuGenome/protembl/*"]]} {
set Keep [OuiOuNon "Do I keep existing files in nucembl and protembl ?"]
}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp "/" $Ligne]} {
ExtraireDe $Ligne NomLu Debut Fin Orient
regsub -nocase {^[A-Z_]+} $NomLu [PreFixe] Nom
lappend LesBornes "$Nom $Debut $Fin $Orient"
set Gene ""
set Product ""
set Note ""
set SeqPro ""
set SeqNuc ""
}
if {$Keep && [file exists "$RepertoireDuGenome/protembl/$Nom"]} { continue }
if {$SeqNuc==""} {
set SeqNuc [BoutADN $Debut $Fin $Orient]
Espionne "$Nom $Debut $Fin $Orient"
set TraNuc [SeqNucToSeqPro $SeqNuc]
set SeqPro $TraNuc
set Attention ""
}
if {[regexp {[^ATGC]} $SeqNuc Autre]} {
append Attention "$Nom $Debut $Fin $Orient degenerated code (between ><): >$Autre<\n$SeqNuc\n"
}
if {[regexp "/translation=" $Ligne]} {
set SeqPro [StringSuivant "/translation=" dans $Ligne]
if {[string range $SeqPro 1 end] != [string range $TraNuc 1 end]} {
append Attention "$Nom $Debut $Fin $Orient\n"
append Attention " Translated Nuc and Prot don't correspond\n"
append Attention "SeqPro > $SeqPro\nSeqNuc > $TraNuc\n"
}
if {$Attention==""} {
set SeqPro $TraNuc
} else {
if {$Previens && [string range $SeqPro 1 end-1] != [string range $TraNuc 1 end]} {
if {[OuiOuNon "Something is wrong with TranslatedNuc and Prot\n\
Do You want to ignore all messages ?"]} {
set NePasPrevenirPourGenBank 1
set Previens 0
} else {
AfficheVariable $Attention "SansRien"
}
}
AppendAuFichier $FichierAttention $Attention
}
}
if {[regexp "/gene=" $Ligne]} {
set Gene [StringSuivant "/gene=" dans $Ligne]
InformeSansDemander $Nom "=GN_GenBank: $Gene"
}
if {[regexp "/product=" $Ligne]} {
set Product [StringSuivant "/product=" dans $Ligne]
InformeSansDemander $Nom "=DE_GenBank: $Product"
}
if {[regexp "/note=" $Ligne]} {
set Note [StringSuivant "/note=" dans $Ligne]
InformeSansDemander $Nom "=NT_GenBank: $Note"
}
if {[info exists SeqPro]} {
set NucTFA [SequenceFormatTFA $SeqNuc "$Nom $Gene $Product" "nucbrut"]
Sauve $NucTFA dans "$RepertoireDuGenome/nuctfa/$Nom"
set LongN [expr $Fin-$Debut+1]
set NucEMBL ""
append NucEMBL "ID $Nom PRELIMINARY; DNA; $LongN Bps."
append NucEMBL "\nAC $Nom"
append NucEMBL "\nOS $NotreOS."
append NucEMBL "\nOC $NotreOC"
if {$Product!=""} { append NucEMBL "\nDE $Product" }
if {$Gene!=""} { append NucEMBL "\nGN $Gene" }
append NucEMBL "\nCC -!- from $Debut to $Fin. Orientation $Orient"
append NucEMBL "\n[QueSequenceFormatEMBL $SeqNuc AvecSQ]"
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
set ProtTFA [SequenceFormatTFA $SeqPro "$Nom $Gene $Product" "protbrut"]
Sauve $ProtTFA dans "$RepertoireDuGenome/prottfa/$Nom"
set ProtEMBL ""
set LongP [expr $LongN/3]
append ProtEMBL "ID $Nom PRELIMINARY; PRT; $LongP AA."
append ProtEMBL "\nAC $Nom"
append ProtEMBL "\nOS $NotreOS."
append ProtEMBL "\nOC $NotreOC"
if {$Product!=""} { append ProtEMBL "\nDE $Product" }
if {$Gene!=""} { append ProtEMBL "\nGN $Gene" }
append ProtEMBl "\nCC -!- taken from a GenBank file"
append ProtEMBL "\nCC -!- from $Debut to $Fin. Orientation $Orient"
append ProtEMBL "\n[QueSequenceFormatEMBL $SeqPro AvecSQ]"
Sauve $ProtEMBL dans "$RepertoireDuGenome/protembl/$Nom"
}
}
SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs"
return 1
}
proc RenommeLesGbkDeBbur {} {
File mkdir "[RepertoireDuGenome]/DeIgbmcNew"
foreach F [glob "[RepertoireDuGenome]/DeIgbmc/*.gbk"] {
regexp {/gene=\"(BB[A-Z]?)[0-9]+} [ContenuDuFichier $F] Match BBZ
File copy $F [RepertoireDuGenome]/DeIgbmcNew/$BBZ.gbk
}
exit
}
proc DecortiqueLesGenBank {Fichiers {OffsetNumero 0}} {
global RepertoireDuGenome
set LesFichiersPresumes [lsort [glob $Fichiers]]
set LesFichiers {}
foreach F $LesFichiersPresumes {
# if { ! [regexp {[0-9]+$} $F]} { continue }
lappend LesFichiers $F
}
if {$LesFichiers=={} && [file exists $Fichiers]} {
set LesFichiers [list $Fichiers]
}
set DebEtFin $LesFichiers
if {[llength $DebEtFin]> 20} {
set DebEtFin [concat [lrange $LesFichiers 0 10 ] [list "..." "..."] [lrange $LesFichiers end-9 end]]
}
if { ! [OuiOuNon "Do I use\n[join $DebEtFin "\n"]\n ?"]} { return "" }
set TestOverlap [OuiOuNon "Do I test for overlap between successiv files ? "]
set OrgaSuppose [file tail $Fichiers]
if {$OrgaSuppose=="*"} {
set OrgaSuppose [file tail $RepertoireDuGenome]
}
regsub "_$" $OrgaSuppose "" OrgaSuppose
set OrgaSuppose "[string toupper [string index $OrgaSuppose 0]][string range $OrgaSuppose 1 end]"
set Repertoire [file dirname [file dirname $Fichiers]]
set FichierProt "$Repertoire/ProteinesDe$OrgaSuppose"
set FichierADN "$Repertoire/SequenceADNDe$OrgaSuppose"
while { ! [OuiOuNon "Do I use the protein file \n$FichierProt\n and the DNA file \n$FichierADN\n ?"]} {
FaireLire "Please select for the files you want to create"
set FichierProt [FichierPourSaveAs $FichierProt]
set FichierADN [FichierPourSaveAs $FichierADN]
if {$FichierProt=="" || $FichierADN==""} {
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
}
while {[file exists $FichierProt] || [file exists $FichierADN]} {
if {[OuiOuNon "Do I replace \n$FichierProt\n and \n$FichierADN\n ?"]} {
File delete -force $FichierProt
File delete -force $FichierADN
} else {
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
if {[OuiOuNon "Do I use them ?"]} { return $FichierADN }
}
if {[regexp "NumeroDans" $OffsetNumero] && [OuiOuNon "Are there more than 1 chromosomes ? "]} {
if {[OuiOuNon "Do You want that I use 10000 offset numbering for each chromosome ?"]} {
set ChromoOffset 10000
while { ! [OuiOuNon "Starting with an offset of $ChromoOffset ?"]} {
incr ChromoOffset 10000
if {$ChromoOffset > 90000} { set ChromoOffset [Entre 00000] }
}
}
}
set OffsetADN 0
set TotaleSequenceADN ""
set OffsetNumeroOri $OffsetNumero
foreach Fichier $LesFichiers {
if {[info exists ChromoOffset]} {
set OffsetNumero "$OffsetNumeroOri+$ChromoOffset"
incr ChromoOffset 10000
}
set Retour [DecortiqueGenBank OS OC SeqADN $Fichier $OffsetADN $OffsetNumero $FichierProt]
if {[scan $Retour "%d %d" OffsetADN OffsetNumeroLu]!=2} {
FaireLire "I got '$Retour' from DecortiqueGenBank.\n\
Something is wrong.\n\
I'll cancel GenBank scanning."
return ""
}
if { $OffsetNumero!="NumeroDansGene" \
&& $OffsetNumero!="NumeroDansNote" \
&& $OffsetNumero!="NumeroDansGeNo" } { set OffsetNumero $OffsetNumeroLu }
if {$TestOverlap} { set SeqADN [NonOverlapingSeqADN $SeqADN] }
append TotaleSequenceADN $SeqADN
}
set TFA [SequenceFormatTFA $TotaleSequenceADN "$Fichiers $OS complete genome" "nucbrut"]
return [Sauve $TFA dans $FichierADN]
}
proc RunDecortiqueGenBank {{Fichier ""} {Destin ""}} {
while {$Fichier==""} {
set Fichier [ButineArborescence "All" "./"]
if {$Fichier=="" && [OuiOuNon "Do i cancel ?"]} { return "" }
}
set Queue [file tail $Fichier]
if {$Destin==""} { set Destin "~/decortiqueGB_$Queue.txt" }
return [SauveLesLignes [DecortiqueGenBank OS OC SeqADN $Fichier] dans $Destin]
}
proc AskForNumberingGenbank {} {
global AskForNumberingGenbank
if {[info exists AskForNumberingGenbank]} { return $AskForNumberingGenbank }
if {[OuiOuNon "Something is wrong with numbering genbank ORFs\n \
Don't panic ... \n\
Do I stop to ask for your help ?"]} {
set AskForNumberingGenbank 0
return 0
}
if {[OuiOuNon "Do I always ask for your help ?"]} {
set AskForNumberingGenbank 1
}
return 1
}
proc DecortiqueGenBank {aOS aOC aSeqADN {FichierOuListeOuTexte ""} {OffsetADN 0} {OffsetNumero 0} {FichierProt ""} {aXrefs ""} {aDbXrefs ""}} {
upvar $aOS OS
upvar $aOC OC
upvar $aSeqADN SeqADN
upvar $aXrefs Xrefs
upvar $aDbXrefs DbXrefs
global RepertoireDuGenome
global NumeroHautPourGenbank
global SupposePrefixe
if {[info exists SupposePrefixe]} { Espionne "SupposePrefixe $SupposePrefixe" }
set Avertir 0
set LesClefsInteressantes {locus_tag gene note product translation protein_id dbx_ref function}
if {$FichierOuListeOuTexte==""} { return "" }
if {[regexp "\n" $FichierOuListeOuTexte]} { set FichierOuListeOuTexte [split $FichierOuListeOuTexte "\n"] }
if {[llength $FichierOuListeOuTexte] < 2 } {
set Fichier $FichierOuListeOuTexte
if {$Fichier=="" || ! [file exists $Fichier]} {
if {[PourWscope]} { return "" }
set Fichier [ButineArborescence "All" $RepertoireDuGenome]
if {$Fichier==""} { return "" }
}
set LesLignes [LesLignesDuFichier $Fichier]
} else {
set LesLignes $FichierOuListeOuTexte
}
set OS ""
set LaSuiteEstPourOC 0
set OC ""
set LaSuiteEstPourCDS 0
set LaSuiteEstPourADN 0
set LongueurLue -1
set RogneEnDebutSIlFaut 1
set LesBornes {}
set LeADN {}
set GeNo ""
set ClefCourante "bidon"
set JoinCar " "
set LaSuiteEstPourXrefs 0
foreach Ligne $LesLignes {
if {$LaSuiteEstPourXrefs} {
lappend LeXrefs [string trim $Ligne]
set Xrefs [join $LeXrefs " "]
if { ! [regexp {\,$} $Ligne]} {
set LaSuiteEstPourXrefs 0
}
Espionne $Xrefs
}
if {$LaSuiteEstPourADN} {
if {[regexp "^ORIGIN" $Ligne]} { continue }
if {[regexp {\.\.} $Ligne]} { continue }
if {[regexp "//" $Ligne]} { break }
regsub -all {[ 0-9]} $Ligne "" LigneADN
if {[regexp -nocase {[^a-z]} $LigneADN] && \
! [OuiOuNon "$Ligne\n is this really a DNA sequence line ?"]} {
if {[OuiOuNon "Do I continue to scan non DNA information ?"]} { set LaSuiteEstPourADN 0 ; continue }
}
lappend LeADN $LigneADN
continue
}
if {[regexp "^DEFINITION " $Ligne]} { set Definition [StringSuivant "DEFINITION" dans $Ligne] }
if {[regexp "^BASE COUNT " $Ligne] || \
[regexp "^SQ" $Ligne] || \
[regexp {^ORIGIN( |$)} $Ligne] || \
([regexp {[^0-9]\.\. *$} $Ligne] && ! [regexp {^ +/} $Ligne])} {
if { ! [regexp {[^0-9]\.\. *$} $Ligne] || \
[OuiOuNon "Please answer Yes if the line \n$Ligne\nis the last line of non DNA information ?"]} {
set LaSuiteEstPourADN 1
continue
}
}
if { ! $LaSuiteEstPourADN} {
regsub {\. \.} $Ligne ".." Ligne
}
if {[regexp "^ACCESSION " $Ligne]} {
regsub "^ACCESSION " $Ligne "" Access
}
if {[regexp "^FT " $Ligne]} {
regsub "^FT " $Ligne "" Ligne
} elseif { 0 && [regexp {^[A-Z][A-Z]} $Ligne]} { continue }
if {[regexp -nocase "^REFERENCE" $Ligne]} {
set LongueurLue [IntegerApres "(bases 1 to " dans $Ligne]
continue
}
if {[regexp {^ +xrefs: } $Ligne]} {
set LaSuiteEstPourXrefs 1
set Xrefs $Ligne
regsub {^xrefs: +} $Xrefs "" Xrefs
set LeXrefs [list $Xrefs]
set Xrefs [join $LeXrefs " "]
Espionne $Xrefs
continue
}
if {[regexp {^ +/db_xref=} $Ligne]} {
set DbXref [StringApres "/db_xref=" dans $Ligne]
set DbXref [string trim $DbXref "\""]
lappend DbXrefs $DbXref
continue
}
set OldGeNo $GeNo
set GeNo ""
if {[regexp {/note=\"locus_tag\: } $Ligne]} {
regsub {/note=\"locus_tag\: } $Ligne "/note=\"" Ligne
}
if {[regexp {/gene=\"BB} $Ligne] && [file tail [RepertoireDuGenome]]=="Bbur"} {
if { [regexp {/gene=\"(BB[A-Z][0-9]+)} $Ligne Match BB] } {
set Lettre [string index $BB 2]
set I [string first $Lettre " ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
regsub "BB$Lettre" $BB "" NN
set GeNo [format "BB%4.4d" [expr [Base10 $NN] + $I*100 + 1000]]
} elseif { [regexp {/gene=\"(BB[0-9]+)} $Ligne Match BB] } {
regsub "BB" $BB "" NN
set GeNo [format "BB%4.4d" [expr [Base10 $NN]]]
}
Espionne "$GeNo $Ligne"
} elseif {[info exists SupposePrefixe] && $SupposePrefixe!="" } {
set REx " /(gene|note)=\"(.+\; *|)$SupposePrefixe\[0-9\]{2,}(i|c|\,|\;|\")"
Espionne $Ligne
if {[regexp $REx $Ligne Match]} {
regsub -all { /(gene|note)=\"|\"} $Match "" GeNo
Espionne " ... avec $GeNo"
if {[regexp {\;|\,} $GeNo Separateur]} {
set REx "$SupposePrefixe\[0-9\]{2,}"
foreach Mot [split $GeNo $Separateur] {
if {[regexp $REx $Mot GeNo]} { break }
}
}
regsub $SupposePrefixe $GeNo "" GeNo
regsub {(i|c)$} $GeNo "" GeNo
Espionne "Hourra $GeNo"
} else {
set GeNo $OldGeNo
}
} elseif {[regexp -nocase { /(gene|note)=\"(.+\; *|)[A-Z]+[0-9]{2,}(i|c|\,|\;|\")} $Ligne Match]} {
regsub -all { /(gene|note)=\"|\"} $Match "" GeNo
if {[regexp {\;|\,} $GeNo Separateur]} {
foreach Mot [split $GeNo $Separateur] {
if {[regexp -nocase {[A-Z]+[0-9]{2,}} $Mot GeNo]} { break }
}
}
regsub {(i|c)$} $GeNo "" GeNo
} else {
set GeNo $OldGeNo
}
if {$LaSuiteEstPourCDS && [regexp {^ {20,}} $Ligne]} {
if { ! [regexp "^ +/" $Ligne]} {
regsub -all "\"" $Ligne "" Valeur
lappend LesValeurs [string trim $Valeur]
set ArrayCDS($Debut,$Fin,$Orient,$ClefCourante) [join $LesValeurs $JoinCar]
}
foreach Clef $LesClefsInteressantes {
if {[regexp "^ +/$Clef" $Ligne]} {
regsub -all " +/$Clef=|\"" $Ligne "" Valeur
set LesValeurs [list [string trim $Valeur]]
set ClefCourante $Clef
if {$ClefCourante=="translation"} {
set JoinCar ""
} else {
set JoinCar " "
}
set ArrayCDS($Debut,$Fin,$Orient,$ClefCourante) [join $LesValeurs $JoinCar]
break
}
}
set ArrayCDS($Debut,$Fin,$Orient,GeNo) $GeNo
continue
}
set LaSuiteEstPourCDS 0
if {[regexp -nocase "^ ORGANISM " $Ligne]} {
regsub -all { \([^\)]+\)} $Ligne "" Ligne
set Genre "Inconnu"
set Espece "inconnu"
scan $Ligne "%s %s %s" Key Genre Espece
set OS "$Genre $Espece"
set LaSuiteEstPourOC 1
continue
}
if {$LaSuiteEstPourOC} {
if {[regexp "^ " $Ligne]} {
append OC "[string trim $Ligne] "
} else {
set OC [string trim $OC]
set LaSuiteEstPourOC 0
}
continue
}
if {[regexp {^(()| )CDS} $Ligne]} {
scan $Ligne "%s %s" Key Bornes
set Reverse [regexp "complement" $Bornes]
set RognerEnDebut 0
set RognerEnFin 0
if {[regexp "<" $Bornes]} { set RognerEnDebut 1}
if {[regexp ">" $Bornes]} { set RognerEnFin 1}
regsub -all {[^0-9]} $Bornes " " Bornes
scan $Bornes "%d %d" Debut Fin
if {$Reverse} {
set Orient "R"
incr Debut 3
} else {
set Orient "F"
incr Fin -3
}
if {[expr ($Fin-$Debut+1)%3] \
&& ($RognerEnDebut && $RognerEnFin || \
! $RognerEnDebut && ! $RognerEnFin )} {
if {$RogneEnDebutSIlFaut} {
set RognerEnDebut 1
set RognerEnFin 0
} else {
set RognerEnDebut 0
set RognerEnFin 1
}
}
while {[expr ($Fin-$Debut+1)%3]} {
if {$RognerEnDebut} { incr Debut }
if {$RognerEnFin} { incr Fin -1 }
}
set RogneEnDebutSIlFaut 0
lappend LesBornes "$Debut $Fin $Orient"
set ArrayCDS($Debut,$Fin,$Orient,GeNo) $GeNo
set LaSuiteEstPourCDS 1
continue
}
}
set SeqADN [join $LeADN ""]
if { ! [info exists NumeroHautPourGenbank]} { set NumeroHautPourGenbank 9999 }
set Numero $OffsetNumero
foreach Bornes $LesBornes {
scan $Bornes "%d %d %s" Debut Fin Orient
set VraiDebut [expr $Debut + $OffsetADN]
set VraiFin [expr $Fin + $OffsetADN]
if {[regexp "NumeroDansGene" $OffsetNumero]} {
set Gene [set ArrayCDS($Debut,$Fin,$Orient,gene)]
if { ! [regexp -nocase {^[A-Z_]+[0-9]+} $Gene]} {
FaireLire "/gene=$Gene isn't a valid ORF name ..."
}
regsub -all {[^0-9]} $Gene "" Numero
set Numero [Base10 $Numero]
if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
incr Numero $Off
}
} elseif {[regexp "NumeroDansNote" $OffsetNumero]} {
set Note [set ArrayCDS($Debut,$Fin,$Orient,note)]
if { ! [regexp -nocase {^[A-Z_]+[0-9]+} $Note Match]} {
FaireLire "/note=$Note isn't a valid ORF name ..."
}
regsub -all {[^0-9]} $Match "" Numero
set Numero [Base10 $Numero]
if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
incr Numero $Off
}
} elseif {[regexp "NumeroDansGeNo" $OffsetNumero]} {
set GeNo [set ArrayCDS($Debut,$Fin,$Orient,GeNo)]
if { ! [regexp -nocase {^[A-Z_]*[0-9]+} $GeNo Match]} {
if {[AskForNumberingGenbank]} {
FaireLire "/geneORnote=$GeNo isn't a valid ORF name ..."
}
set Match $NumeroHautPourGenbank
}
regsub -all {[^0-9]} $Match "" Numero
set Numero [Base10 $Numero]
if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
incr Numero $Off
}
} elseif {[regexp "NumeroDansLocusTag" $OffsetNumero]} {
set GeNo [set ArrayCDS($Debut,$Fin,$Orient,locus_tag)]
if { ! [regexp -nocase {^[A-Z_]*[0-9]+} $GeNo Match]} {
if {[AskForNumberingGenbank]} {
FaireLire "/locus_tag=$GeNo isn't a valid ORF name ..."
}
set Match $NumeroHautPourGenbank
}
regsub -all {[^0-9]} $Match "" Numero
set Numero [Base10 $Numero]
if {[regexp {\+([0-9]+)} $OffsetNumero Match Off]} {
incr Numero $Off
}
} else {
incr Numero
}
while {[info exists DejaVu($Numero)]} {
set Ask [AskForNumberingGenbank]
if {$Ask && [OuiOuNon "I saw already the ORF number $Numero. Do I skipp ?" 0]} { break }
if { ! $Ask || [OuiOuNon "Can You give me an other one ?"]} {
if {$Ask} {
set Autre [Base10 [Entre $NumeroHautPourGenbank]]
} else {
set Autre [Base10 $NumeroHautPourGenbank]
}
if {$Autre==$NumeroHautPourGenbank} { incr NumeroHautPourGenbank -1 }
if {$Autre==""} { continue }
set Numero $Autre
}
}
if {[info exists DejaVu($Numero)]} { continue }
set BeauNumero [format "%4.4d" $Numero]
set DejaVu($Numero) 1
set Nom "ORF$BeauNumero"
set Info "$Nom $VraiDebut $VraiFin $Orient"
if {$FichierProt!=""} {
AppendAuFichier $FichierProt $Info
} else {
lappend LeRetour $Info
if {[info exists Access]} { lappend LeRetour "$Nom /Access=$Access" }
if {[info exists OS ]} { lappend LeRetour "$Nom /OS=$OS" }
if {[info exists OC ]} { lappend LeRetour "$Nom /OC=$OC" }
if {[info exists LeADN ]} { lappend LeRetour "$Nom /ADN=[Transcript $Bornes SeqADN]"}
}
foreach Clef $LesClefsInteressantes {
if { ! [info exists ArrayCDS($Debut,$Fin,$Orient,$Clef)]} { continue }
set Info "$Nom /$Clef=[set ArrayCDS($Debut,$Fin,$Orient,$Clef)]"
if {$FichierProt!=""} {
AppendAuFichier $FichierProt $Info
} else {
lappend LeRetour $Info
}
}
}
set LongADN [string length $SeqADN]
if {$Avertir && $LongueurLue>0 && $LongADN!=$LongueurLue} {
FaireLire "During DecortiqueGenBank $Fichier\n\
Longueur lue $LongueurLue != Longueur reelle $LongADN"
}
if {$FichierProt==""} {
if {[info exists Access]} { lappend LeRetour "ORF_ALL /Access=$Access" }
if {[info exists OS]} { lappend LeRetour "ORF_ALL /OS=$OS" }
if {[info exists OC]} { lappend LeRetour "ORF_ALL /OC=$OC" }
if {[info exists Definition]} { lappend LeRetour "ORF_ALL /DEFINITION=$Definition" }
if {[info exists LeADN]} { lappend LeRetour "ORF_ALL /DNA=$SeqADN" }
return $LeRetour
} else {
return "[expr $OffsetADN+$LongADN] $Numero"
}
}
proc TestChaqueProteineDuTBlastN Nom {
global RepertoireDuGenome
set Fichier "$RepertoireDuGenome/tblastngenomes/$Nom"
if { ! [file exists $Fichier]} { return "" }
Espionne [join [ChaqueProteineDuTBlastN $Fichier] "\n"]
exit
}
proc OffsetEtOrganismeDuFragment {Fragment {NomDeLaBanque ""}} {
global OffsetEtOrganismeDuFragment
global CorrectionDuAccessDuFragment
global RepertoireDuGenome
if {[regexp {GENBANK.*\:} $Fragment]} {
set LesMots [LesMotsDeLaLigne $Fragment]
set LesGenres [lrange $LesMots 2 end]
set LesEspeces [lrange $LesMots 3 end]
set Genre "Unknown"
set Espece "unknown"
foreach Genre $LesGenres Espece $LesEspeces {
if {[regexp {^[A-Z][a-z]+$} $Genre] && [regexp {^[a-z]+$} $Espece]} { break }
set Genre "Unknown"
set Espece "unknown"
}
return "0 $Genre $Espece [Tax "$Genre $Espece"]"
}
global SansOffsetEtOrganisme
if {[info exists SansOffsetEtOrganisme] && $SansOffsetEtOrganisme} {
return "0 Inconnu inconnu"
}
Wup "NomDeLaBanque can be a file in BlastBanks or an other file in absolute notation"
set BlastBanks "$RepertoireDuGenome/banques"
if {$NomDeLaBanque==""} {
if {[regexp -nocase "msme\:" $Fragment]} {
set BlastBank "$BlastBanks/MSoverlap"
} else {
set BlastBank "$BlastBanks/completegenomes"
}
} else {
set BlastBank $NomDeLaBanque
if {[file exists $BlastBank] || [file exists $BlastBank.nhr] || [file exists $BlastBank.nal]} {
} else {
set BlastBank "$BlastBanks/$NomDeLaBanque"
}
}
if { ! [info exists CorrectionDuAccessDuFragment]} {
set CorrectionDuAccessDuFragment("EstCharge") 1
set FichierCorrection "$BlastBank.correction"
if {[file exists $FichierCorrection]} {
foreach Ligne [LesLignesDuFichier $FichierCorrection] {
scan $Ligne "%s %s" Old New
set Old [string toupper $Old]
set CorrectionDuAccessDuFragment($Old) $New
}
}
}
scan $Fragment "%s" Access
set ACCESS [string toupper $Access]
if {[info exists CorrectionDuAccessDuFragment($ACCESS)]} {
set New [set CorrectionDuAccessDuFragment($ACCESS)]
regsub "$Access" $Fragment $New Fragment
}
if {[regexp -nocase {[a-z0-9_]+\:} $Fragment Banque]} {
set BANQUE [string toupper $Banque]
regsub $Banque $Fragment $BANQUE Fragment
} else {
Espionne $Fragment
set BANQUE "BANKUNK:"
}
# regsub -nocase {^CPNE2\:} $Fragment "CPNEU2:" Fragment
# regsub -nocase {^CPNE3\:} $Fragment "CPNEU3:" Fragment
regsub {\:} $BANQUE "" BANQUE
if {[file exists "$BlastBanks.banks"]} {
set LesBanks [LesLignesDuFichier "$BlastBanks.banks"]
if {[lsearch -exact $LesBanks $BANQUE] == -1 && $BANQUE!="YE"} {
set LesBanksEtMoi $LesBanks
lappend LesBanksEtMoi $BANQUE
set LesBanksEtMoi [lsort $LesBanksEtMoi]
set Moi [lsearch $LesBanksEtMoi $BANQUE]
set Avant [lindex $LesBanksEtMoi [expr $Moi - 1]]
set Apres [lindex $LesBanksEtMoi [expr $Moi + 1]]
set i 0
while {1} {
set A [string index $Avant $i]
set M [string index $BANQUE $i]
set P [string index $Apres $i]
incr i
if {$A==$M && $M==$P} { continue }
if {$A==$M} { set Bon $Avant } else { set Bon $Apres }
break
}
Espionne "$Avant $BANQUE $Apres $Bon"
regsub "$BANQUE" $Fragment $Bon Fragment
}
}
# regsub -nocase {^WORM[IVX]+\:} $Fragment "WORM:" Fragment
if { ! [info exists OffsetEtOrganismeDuFragment("EstCharge",$BlastBank)]} {
set FichierFragments "$BlastBank.frag"
if { ! [file exists $FichierFragments]} {
set FichierFragments [GereLesFragmentsDeLaBanqueBlast $BlastBank]
if {$FichierFragments==""} { return "" }
}
foreach Ligne [LesLignesDuFichier $FichierFragments] {
set TaxId -1
scan $Ligne "%s %s %s %s %s %s %s %s %s %s %s" \
BanqueId BanqueLu Nba Id Nid F DebutFragment OffsetDuFragment Genre Espece TaxId
# if {"$Genre $Espece"=="Buchnera sp"} { set Espece "aphidicola" }
set OffsetEtOrganismeDuFragment($BanqueId,$BlastBank) "$OffsetDuFragment $Genre $Espece $TaxId"
}
}
set OffsetEtOrganismeDuFragment("EstCharge",$BlastBank) 1
if {[info exists OffsetEtOrganismeDuFragment($Fragment,$BlastBank)]} {
return [set OffsetEtOrganismeDuFragment($Fragment,$BlastBank)]
}
set FRAGMENT [string toupper $Fragment]
if {[info exists OffsetEtOrganismeDuFragment($FRAGMENT,$BlastBank)]} {
return [set OffsetEtOrganismeDuFragment($FRAGMENT,$BlastBank)]
}
return "0 Unknown unknown"
}
proc GereLesFragmentsDeLaBanqueBlast BlastBank {
global RepertoireDuGenome
set LesGenomesEnSouches {CPNE NMEN HPYL}
set LesGenomesEnSouchesChromosomiques {DRA VCH}
set FichierHeaders "$BlastBank.header"
set FichierCorrections "$BlastBank.correction"
set FichierFragments "$BlastBank.frag"
if {[file exists $FichierCorrections]} {
foreach Ligne [LesLignesDuFichier $FichierCorrections] {
scan $Ligne "%s %s" A BA
set BonBA([string toupper $A]) [string toupper $BA]
}
}
if { ! [file exists $FichierHeaders] && [regexp "completegenomes" $BlastBank]} {
if {[OuiOuNonMemo "Maybe I'll need headers from $BlastBank. You should first create \n$FichierHeaders \n \
with 'gscope CreationDuNalDesGenomesComplets PleaseAsk PleaseAsk PleaseAsk'\n\
If not I'll try do do what I can. Bye bye !"]} {}
return ""
}
if {[file exists $FichierHeaders]} {
set LesHeaders [LesLignesDuFichier $FichierHeaders]
} else {
foreach Ligne [LesLignesDuFichier $BlastBank] {
if {[regexp "^>" $Ligne]} {
lappend LesHeaders $Ligne
}
}
}
set LaListe {}
set Organisme ""
foreach Ligne $LesHeaders {
if { ! [regexp -nocase {[a-z]+} $Ligne ]} { continue }
regsub ">" $Ligne "" Ligne
set Ligne [string toupper $Ligne]
scan $Ligne "%s" BanqueNIdNF
if { ! [regexp ":" $BanqueNIdNF] && [info exists BonBA($BanqueNIdNF)]} {
regsub "^$BanqueNIdNF" $Ligne [set BonBA($BanqueNIdNF)] Ligne
set BanqueNIdNF $BanqueNIdNF
}
set DebutFragment 1
if {[regexp "FROM BASE" $Ligne]} {
set DebutFragment [IntegerApres "FROM BASE" dans $Ligne]
}
if {[regexp "from:" $Ligne]} {
set DebutFragment [IntegerApres "FROM:" dans $Ligne]
}
ScanLaListe [split $BanqueNIdNF ":"] BanqueN IdNF
set BanqueN [string toupper $BanqueN]
set BanqueNIdNF "$BanqueN:$IdNF"
regexp -nocase {[a-z]+} $BanqueN Banque
set Nba 0
if {[regexp {[0-9]+} $BanqueN Nlu]} { set Nba $Nlu }
set OriginalBanqueN($Banque,$Nba) $BanqueN
set F 0
set IdN $IdNF
if {[regexp "_" $IdNF]} {
ScanLaListe [split $IdNF "_"] IdN F
}
regexp -nocase {[a-z]+} $IdN Id
set Nid 0
if {[regexp -nocase {[0-9]+} $IdN Nlu]} { set Nid [Base10 $Nlu] }
set OriginalIdN($Banque,$Nba,$Id,$Nid) $IdN
set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F) $IdNF
set OriginalLigne($Banque,$Nba,$Id,$Nid,$F) $BanqueNIdNF
if { ! [info exists OrganismeDe($Banque)]} {
set Organisme ""
if {[regexp -nocase { [A-Za-z0-9_]+ [A-Z][a-z]+ [a-z]+\.?} $Ligne Match]} {
regsub -nocase { [A-Za-z0-9_]+ } $Match "" Organisme
set Organisme [Glossaire $Organisme Complet]
}
if {$Organisme==""} {
if {$Banque=="BUCH"} { set Organisme "Buchnera sp" }
if {$Banque=="BBURG"} { set Organisme "Borrelia burgdorferi" }
if {$Banque=="BBUR"} { set Organisme "Borrelia burgdorferi" }
if {$Banque=="DRA"} { set Organisme "Deinococcus radiodurans" }
if {$Banque=="STYP"} { set Organisme "Salmonella typhi" }
if {$Banque=="SYNE"} { set Organisme "Synechocystis sp" }
if {$Banque=="AERO"} { set Organisme "Aeropyrum pernix" }
if {$Banque=="YE"} { set Organisme "Saccharomyces cerevisiae" }
if {$Organisme!=""} { set Organisme [Glossaire $Organisme Complet] }
}
if {$Organisme==""} { set Organisme [Glossaire $Banque Complet] }
while {$Organisme==""} {
FaireLire "$Ligne\n no organism detected.\n Please help me ..."
set OrganismePropose [Entre]
set Organisme [Glossaire $OrganismePropose Complet]
if {$Organisme!=""} { break }
if {[OuiOuNon "I don't know $OrganismePropose as organism name\n\
Do You want to keep it ?" ]} {
set Organisme $OrganismePropose
break
}
}
set OrganismeDe($Banque) $Organisme
}
Espionne "$Banque $Nba $Id $Nid $F $DebutFragment $Organisme"
lappend LaListe [list $Banque $Nba $Id $Nid $F $DebutFragment]
}
set LaListeBanque [lsort -index 0 $LaListe]
set LaListe {}
foreach Element $LaListeBanque {
ScanLaListe $Element Banque Nba Id Nid F DebutFragment
if {[lsearch -exact $LesGenomesEnSouches $Banque]!=-1} {
set OriIdN [set OriginalIdN($Banque,$Nba,$Id,$Nid)]
set OriIdNF [set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F)]
set OriLign [set OriginalLigne($Banque,$Nba,$Id,$Nid,$F)]
set OriginalIdN($Banque,$Nba,$Id,$Nid) $OriIdN
set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F) $OriIdNF
set OriginalLigne($Banque,$Nba,$Id,$Nid,$F) $OriLign
}
if {[lsearch -exact $LesGenomesEnSouchesChromosomiques $Banque]!=-1} {
set OriIdN [set OriginalIdN($Banque,$Nba,$Id,$Nid)]
set OriIdNF [set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F)]
set OriLign [set OriginalLigne($Banque,$Nba,$Id,$Nid,$F)]
set Nid $Nba
set Nba 0
set OriginalIdN($Banque,$Nba,$Id,$Nid) $OriIdN
set OriginalIdNF($Banque,$Nba,$Id,$Nid,$F) $OriIdNF
set OriginalLigne($Banque,$Nba,$Id,$Nid,$F) $OriLign
}
lappend LaListe [list $Banque $Nba $Id $Nid $F $DebutFragment]
}
foreach Element [lsort -index 0 $LaListe] {
ScanLaListe $Element Banque Nba Id Nid F DebutFragment
lappend SaListe($Banque) [list $Banque $Nba $Id $Nid $F $DebutFragment]
if {[info exists DejaVu($Banque)]} { continue }
set DejaVu($Banque) 1
lappend LesBanquesDansLOrdre $Banque
}
foreach Banque $LesBanquesDansLOrdre {
foreach Element [lsort -index 2 [set SaListe($Banque)]] {
ScanLaListe $Element BanqueLu Nba Id Nid F DebutFragment
lappend SaListe($BanqueLu,$Id) [list $BanqueLu $Nba $Id $Nid $F $DebutFragment]
if {[info exists DejaVu($BanqueLu,$Id)]} { continue }
set DejaVu($BanqueLu,$Id) 1
lappend LesBanquesIdDansLOrdre "$BanqueLu,$Id"
}
}
foreach BanqueId $LesBanquesIdDansLOrdre {
foreach Element [lsort -integer -index 3 [set SaListe($BanqueId)]] {
ScanLaListe $Element BanqueLu Nba Id Nid F DebutFragment
lappend SaListe($BanqueLu,$Id,$Nid) [list $BanqueLu $Nba $Id $Nid $F $DebutFragment]
# Espionne "BanqueIdN $BanqueLu $Nba $Id $Nid $F $DebutFragment"
if {[info exists DejaVu($BanqueLu,$Id,$Nid)]} { continue }
set DejaVu($BanqueLu,$Id,$Nid) 1
lappend LesBanquesIdNDansLOrdre "$BanqueLu,$Id,$Nid"
}
}
ScanLaListe {-1 -1 -1 -1 -1 -1} oBanqueLu oNba oId oNid oF oDebutFragment
foreach BanqueIdN $LesBanquesIdNDansLOrdre {
set SaListe($BanqueIdN) [lsort -integer -index 5 [set SaListe($BanqueIdN)]]
foreach Element [set SaListe($BanqueIdN)] {
ScanLaListe $Element BanqueLu Nba Id Nid F DebutFragment
if {$BanqueLu != $oBanqueLu || $Nba != $oNba} { set Offset 0 }
if {$BanqueLu == $oBanqueLu && $Nba == $oNba && ($Id != $oId || $Nid != $oNid)} {
set Offset [expr $oDebutFragment + 200000]
}
set NewDebutFragment [expr $Offset+$DebutFragment]
set OffsetDuFragment [expr $NewDebutFragment - 1]
set Organisme [set OrganismeDe($BanqueLu)]
set BA [set OriginalLigne($BanqueLu,$Nba,$Id,$Nid,$F)]
set B [lindex [split $BA ":"] 0]
Espionne "$B $BA"
set TaxId [TaxIdDuGenomeComplet $B]
while {$TaxId==""} {
if {[info exists DejaDemandeTaxID($B)]} {
set TaxId [set DejaDemandeTaxID($B)]
break
}
set OB [Glossaire $B "Complet"]
set TOB [Tax $OB]
FaireLire "I couldn't find TaxIdDuGenomeComplet $B\nPlease help me.\
$B could be '$OB'\nits TaxId is '$TOB'"
set TaxId [Entre $TOB]
}
set DejaDemandeTaxID($B) $TaxId
if { ! [info exists DejaVerifie($TaxId)]} {
set Name [Tax $TaxId Name]
if { ! [regexp $Organisme $Name]} {
FaireLire "$TaxId = $Name is not $Organisme"
}
set DejaVerifie($TaxId) $Organisme
} else {
if {[set DejaVerifie($TaxId)]!=$Organisme} {
FaireLire "$TaxId was [set DejaVerifie($TaxId)] now I found $Organisme"
}
}
lappend Sortie "$BA\
$BanqueLu $Nba $Id $Nid $F $DebutFragment $OffsetDuFragment $Organisme $TaxId"
set oElement $Element
ScanLaListe $oElement oBanqueLu oNba oId oNid oF
set oDebutFragment $NewDebutFragment
}
}
return [SauveLesLignes $Sortie dans $FichierFragments]
}
proc LesCopains {FichierBlastP FichierSortie} {
Espionne [SauveLesLignes [LesCandidatsPourClustalW $FichierBlastP "blastp"] dans $FichierSortie]
}
proc GCGtoTFA {TexteGCG {Entete ""}} {
return [SequenceFormatTFA $Texte "Entete" "gcg"]
}
proc GCGtoTFAPourToutLeRepertoire {} {
foreach F [glob "*.nuc"] {
set Nom [file tail $F]
regsub {\.nuc} $Nom "" Nom
set TFA [SequenceFormatTFA [ContenuDuFichier $F] "$Nom Cloning vector $Nom" "gcg"]
Espionne [Sauve $TFA dans "$Nom.tfa"]
}
exit
}
proc SequenceFormatGCGDuFichier {Fichier {NomDeBapteme ""} {Format ""}} {
set Sequence [QueLaSequenceDuFichierTFA $Fichier]
Espionne $Sequence
return [SequenceFormatGCG $Sequence $NomDeBapteme $Format]
}
proc SequenceFormatGCG {Sequence {NomDeBapteme ""} {Format ""}} {
Wup "Converts to GCG but doesn't yet use NomDeBapteme"
NousAllonsAuBoulot
set FichierTmpTfa "[TmpFile].tfa"
regsub ".tfa$" $FichierTmpTfa ".list" FichierTmpList
Sauve [SequenceFormatTFA $Sequence $NomDeBapteme $Format] dans $FichierTmpTfa
set Seq [QueLaSequenceDuFichierTFA $FichierTmpTfa]
set Long [string length $Seq]
set YaAA [expr [regexp -nocase {[^ATGCN]} $Seq]]
if {$YaAA} { set NucOuPro "protein" } else { set NucOuPro "nuc" }
Espionne "fromfasta -begin=1 -end=$Long -$NucOuPro $FichierTmpTfa -List=$FichierTmpList"
catch {exec fromfasta -begin=1 -end=$Long -$NucOuPro $FichierTmpTfa -List=$FichierTmpList}
if { ! [file exists $FichierTmpList]} {
File delete -force $FichierTmpTfa
OnRevientDuBoulot
return "Error : I couln't find the list of filenames."
}
foreach Ligne [LesLignesDuFichier $FichierTmpList] {
if { ! [info exists DejaVuPP]} {
if {[regexp {\.\. *$} $Ligne ]} { continue }
set DejaVuPP 1
}
set FichierTmpPep ""
scan $Ligne "%s" FichierTmpPep
if {$FichierTmpPep==""} { continue }
}
if { ! [file exists $FichierTmpPep]} {
File delete -force $FichierTmpTfa
File delete -force $FichierTmpList
return "Error : I couln't find the converted file"
}
set GCG [ContenuDuFichier $FichierTmpPep]
# File delete -force $FichierTmpTfa
# File delete -force $FichierTmpPep
# File delete -force $FichierTmpList
OnRevientDuBoulot
Espionne $GCG
return $GCG
}
proc NucToProtTFA {Sequence {NomDeBapteme ""} {Format ""}} {
if {$Format==""} { set Format [FormatDeLaSequence $Sequence] }
if {$Format != "tfa"} {
FaireLire "Desole, NucToProtTFA ne sait pas encore traduire le format $Format"
return ""
}
if {$NomDeBapteme!=""} {
set Entete ">$NomDeBapteme"
} else {
set iR [string first "\n" $Sequence]
set Entete [string range $Sequence 0 [incr iR -1]]
}
set SeqNuc [QueLaSequence $Sequence]
set SeqPro [SeqNucToSeqPro $SeqNuc]
return "$Entete\n[SequenceFormatBrut $SeqPro]"
}
proc LesGenomesCompletsPossibles {{Format Court}} {
Wup "Is obsolete"
return [LesGenomesCompletsAuFormat $Format]
}
proc LesGenomesCompletsAuFormat {{Format Court}} {
foreach Organisme [LesGenomesComplets] {
lappend LesGCF [Glossaire $Organisme $Format]
}
return $LesGCF
}
proc LesGenomesCompletsPourGlossaire {} {
global Glossaire
Wup "To run faster for the most used orgs"
foreach G [LesGenomesComplets] {
regsub " " $G "_" G
set Court [Glossaire $G Court]
set Glossaire($Court,Court) $Court
set Glossaire($Court,Complet) [Glossaire $G Complet]
set Glossaire($Court,COMPLET) [Glossaire $G COMPLET]
set Glossaire($Court,Demi) [Glossaire $G Demi]
set Glossaire($Court,Tout) [Glossaire $G Tout]
}
}
proc LesGenomesComplets {} {
global RepertoireDuGenome
global LesGenomesComplets
global Glossaire
if {[info exists LesGenomesComplets]} { return $LesGenomesComplets }
set FichierLesGenomesComplets "[RepertoireDuGenome]/fiches/lesgenomescomplets"
if {[file exists $FichierLesGenomesComplets]} {
set LesGenomesComplets {}
foreach Ligne [LesLignesDuFichier $FichierLesGenomesComplets] {
set Genre ""
set Espece ""
scan $Ligne "%s %s" Genre Espece
if {$Espece==""} { continue }
lappend LesGenomesComplets "$Genre $Espece"
}
return $LesGenomesComplets
}
if { ! [file exists "[RepertoireDuGenome]/fiches"]} {
file mkdir "[RepertoireDuGenome]/fiches"
}
catch { if {[file type $FichierLesGenomesComplets]=="link"} { file delete -force $FichierLesGenomesComplets } }
set FichierLesGenomesCompletsDefaut "[GscopeEtc]/gscope_lesgenomescomplets"
if {[file exists $FichierLesGenomesCompletsDefaut]} {
if { 1 || [OuiOuNon "I need the file with all complete genomes.\n\
Can I copy $FichierLesGenomesCompletsDefaut ?"]} {
if { [catch {file copy $FichierLesGenomesCompletsDefaut $FichierLesGenomesComplets}]} { return {} }
return [LesGenomesComplets]
}
}
FaireLire "I need the file of all complete genomes\n \
I will ask You to select a file\n \
OR\n\
You can copy or link it from an other directory to\n\
$FichierLesGenomesComplets\n\
(You can do it before Acknowledge)"
if { ! [file exists $FichierLesGenomesComplets]} {
set Ailleurs [ButineArborescence "All" "$RepertoireDuGenome/../lesgenomescomplets"]
if {$Ailleurs!=""} {
if {[OuiOuNon "Ok to copy\n $Ailleurs\nto\n $FichierLesGenomesComplets\n?"]} {
File copy $Ailleurs $FichierLesGenomesComplets
} else {
if {[OuiOuNon "Do I exit ?"]} { exit }
}
}
}
return [LesGenomesComplets]
}
proc CreeLesPABsAvecUnProteomeEtADN {{FichierTFAsDuProteome ""}} {
global RepertoireDuGenome
global FichierSequenceADN
if {$FichierTFAsDuProteome==""} {
set RepertoireParDefaut "$RepertoireDuGenome/DeGold/"
if { ! [file exists $RepertoireParDefaut]} {
set RepertoireParDefaut "$RepertoireDuGenome/"
}
set FichierTFAsDuProteomeParDefaut [glob -nocomplain "${RepertoireParDefaut}/*.ffa"]
if { ! [file exists $FichierTFAsDuProteomeParDefaut] } {
set FichierTFAsDuProteomeParDefaut $RepertoireParDefaut
}
set FichierTFAsDuProteome [ButineArborescence "All" $FichierTFAsDuProteomeParDefaut]
}
if {$FichierTFAsDuProteome==""} { return {} }
set FichierBornesDuProteome [LocaliseLeProteome $FichierTFAsDuProteome]
if {$FichierBornesDuProteome==""} { return {} }
set RepertoireProteomeTFA "$RepertoireDuGenome/proteometfa"
if { ! [file exists $RepertoireProteomeTFA]} {
File mkdir $RepertoireProteomeTFA
}
set Keep 0
if {[llength [glob -nocomplain "$RepertoireProteomeTFA/*"]]} {
set Keep [OuiOuNon "Do I keep existing files in \n$RepertoireProteomeTFA/\n ?"]
}
set Numero 0
foreach Access [LaSequenceDuTFAs $FichierTFAsDuProteome "LaListeDesAccess"] \
Bornes [LesLignesDuFichier $FichierBornesDuProteome] {
ExtraireDe $Bornes AccessLu Debut Fin Orient
set Seq [LaSequenceDuTFAs $FichierTFAsDuProteome $Access]
if { ! [regexp -nocase {\([a-z0-9_\-]+\)} $Seq GN]} { set GN "" }
set Nom [format "%s%4.4d" [PreFixe] [incr Numero]]
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
if {$Keep && [file exists "$RepertoireProteomeTFA/$Nom"]} { continue }
set SeqPro [QueLaSequence $Seq]
set SeqNuc [BoutADN $Debut $Fin $Orient]
set TraNuc [SeqNucToSeqPro $SeqNuc]
set Attention ""
if {[regexp {[^ATGC]} $SeqNuc Autre]} {
Warne "$Nom $Bornes $Autre\n$SeqNuc"
set Attention "Degenerated code $Autre "
}
if {[string range $SeqPro 1 end] != [string range $TraNuc 1 end]} {
append Attention " TranslNuc and Prot don't correspond \n"
}
regsub ">" $Seq ">$Nom $Debut $Fin $Orient $Attention" Seq
Espionne [Sauve $Seq dans "$RepertoireProteomeTFA/$Nom"]
}
Espionne [SauveLesLignes $LesBornesDesPABs dans "[RepertoireDuGenome]/fiches/bornesdespabs.proteome"]
return $LesBornesDesPABs
}
proc CreeLesPABsAvecUnProteomeDansTFAs {{FichierTFAsDuProteome ""}} {
global RepertoireDuGenome
global FichierSequenceADN
global LongueurMiniDesORFs
if {[OuiOuNon "Do I use a DNA file ?"]} {
FaireLire "Sorry the program has to be written ... "
return ""
} else {
set AvecADN 0
if { ! [info exists FichierSequenceADN] || ! [regexp -nocase {[a-z]} $FichierSequenceADN] } {
set FichierSequenceADN "$RepertoireDuGenome/beton/adn_fantome"
}
if {! [file exists $FichierSequenceADN]} {
Sauve "xATGC" dans $FichierSequenceADN
}
}
if { ! [info exists LongueurMiniDesORFs]} { set LongueurMiniDesORFs 300 }
if {$FichierTFAsDuProteome==""} {
set RepertoireParDefaut [lindex [glob -nocomplain "$RepertoireDuGenome/De*"] 0]
if { ! [file exists $RepertoireParDefaut]} {
set RepertoireParDefaut "$RepertoireDuGenome/"
}
set FichierTFAsDuProteomeParDefaut [glob -nocomplain "${RepertoireParDefaut}/*.tfa"]
if { ! [file exists $FichierTFAsDuProteomeParDefaut] } {
set FichierTFAsDuProteomeParDefaut $RepertoireParDefaut
}
set FichierTFAsDuProteome [ButineArborescence "All" $FichierTFAsDuProteomeParDefaut]
}
if {$FichierTFAsDuProteome==""} { return {} }
if {$AvecADN} {
set FichierBornesDuProteome [LocaliseLeProteome $FichierTFAsDuProteome]
if {$FichierBornesDuProteome==""} { return {} }
}
set RepertoireProteomeTFA "$RepertoireDuGenome/proteometfa"
if { ! [file exists $RepertoireProteomeTFA]} {
File mkdir $RepertoireProteomeTFA
}
set Keep 0
if {[llength [glob -nocomplain "$RepertoireProteomeTFA/*"]]} {
set Keep [OuiOuNon "Do I keep existing files in \n$RepertoireProteomeTFA/\n ?"]
}
if {[OuiOuNon "Do I use numbering from tfa file ?"]} {
set Auto 0
set NumeroAuto 10000
} else {
set Auto 1
set NumeroAuto 0
}
set Orient "F"
set Debut 1
foreach Access [LaSequenceDuTFAs $FichierTFAsDuProteome "LaListeDesAccess"] {
incr Debut [expr $LongueurMiniDesORFs + 100]
set Fin [expr $Debut+$LongueurMiniDesORFs]
incr NumeroAuto
set Seq [LaSequenceDuTFAs $FichierTFAsDuProteome $Access]
set Head [lindex [split $Seq "\n"] 0]
regsub ">" $Head "" DE
if { ! [regexp -nocase {\([a-z0-9_\-]+\)} $Seq GN]} { set GN "" }
if { ! [regexp -nocase {[0-9]+} $Access Numero]} { set Numero $NumeroAuto }
while {[regexp {^0[0-9]+} $Numero]} { regsub {^0} $Numero "" Numero }
set Nom [format "%s%4.4d" ORF $Numero]
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
if {$Keep && [file exists "$RepertoireProteomeTFA/$Nom"]} { continue }
set SeqPro [QueLaSequence $Seq]
if {$AvecADN} {
set SeqNuc [BoutADN $Debut $Fin $Orient]
set TraNuc [SeqNucToSeqPro $SeqNuc]
set Attention ""
if {[regexp {[^ATGC]} $SeqNuc Autre]} {
Warne "$Nom $Bornes $Autre\n$SeqNuc"
set Attention "Degenerated code $Autre "
}
if {[string range $SeqPro 1 end] != [string range $TraNuc 1 end]} {
append Attention " TranslNuc and Prot don't correspond \n"
}
regsub ">" $Seq ">$Nom $Debut $Fin $Orient $Attention" Seq
} else {
set Seq [SequenceFormatTFA $SeqPro ">$Nom $DE" "protbrut"]
}
Espionne [Sauve $Seq dans "$RepertoireProteomeTFA/$Nom"]
}
Espionne [SauveLesLignes $LesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs.proteome"]
return $LesBornesDesPABs
}
proc AccessAlternatif Access {
global AccessAlternatif
global RepertoireDuGenome
if {[info exists AccessAlternatif($Access)]} { return [set AccessAlternatif($Access)] }
if {[info exists AccessAlternatif("EstCharge")]} {
if {[regexp {[a-z]} $Access]} {
return [AccessAlternatif [string toupper $Access]]
} else {
return ""
}
}
set FichierAccessAlternatif "$RepertoireDuGenome/../accessalternatif"
if { ! [file exists $FichierAccessAlternatif]} { return "" }
foreach Ligne [LesLignesDuFichier $FichierAccessAlternatif] {
scan $Ligne "%s %s" Ancien Nouveau
set AccessAlternatif($Ancien) $Nouveau
set AccessAlternatif([string toupper $Ancien]) $Nouveau
set AccessAlternatif($Nouveau) $Ancien
set AccessAlternatif([string toupper $Nouveau]) $Ancien
}
set AccessAlternatif("EstCharge") "EstCharge"
return [AccessAlternatif $Access]
}
proc LocaliseLeProteome {FichierTFAsDuProteome {DernierBon ""}} {
global RepertoireDuGenome
set FichierBornes "$RepertoireDuGenome/fiches/bornesduproteome"
set FichierTmp "[RepertoireDeTravail]/tmp.localise.[PreFixe]"
while {[file exists $FichierBornes]} {
if {[OuiOuNon "$FichierBornes already exists.\nDo I append to it ?"]} { break }
if {[OuiOuNon "Do I accept it ?"]} { return $FichierBornes }
if {[OuiOuNon "Do I delete $FichierBornes ?"]} { break }
if {[OuiOuNon "Do I cancel Proteome localisation ?"]} { return "" }
if {[OuiOuNon "Do I stop ?"]} { exit }
}
if {$DernierBon == ""} {
set AttendLeDernierBon 0
} else {
set AttendLeDernierBon 1
}
foreach Access [LaSequenceDuTFAs $FichierTFAsDuProteome "LaListeDesAccess"] {
if {$AttendLeDernierBon} {
set AttendLeDernierBon [regexp $DernierBon $Access]
continue
}
File delete -force "$FichierTmp"
File delete -force "$FichierTmp.tblastn"
set Query [LaSequenceDuTFAs $FichierTFAsDuProteome $Access]
regsub "^>" $Query ">$FichierTmp $FichierTmp " Query
set FichierTFA [Sauve $Query dans "$FichierTmp"]
set Bornes [LocaliseLaProteineSurLeGenome $FichierTFA]
scan $Bornes "%d %d" Debut Fin
set Orient "F"
if {$Debut>$Fin} {
set Orient "R"
set W $Debut
set Debut $Fin
set Fin $W
}
AppendAuFichier $FichierBornes "$Access $Debut $Fin $Orient"
}
return $FichierBornes
}
proc LocaliseLaProteineSurLeGenome {FichierTFA} {
global RepertoireDuGenome
global FichierSequenceADN
set NomDeLaBanque "$RepertoireDuGenome/banques/[PreFixe]"
if { ! [file exists "$NomDeLaBanque.nhr"]} {
CreeUneBanqueBlast $FichierSequenceADN $NomDeLaBanque
}
if { ! [regexp "/" $FichierTFA] && [YaPABouTROUouTRNAouARNenDebutDe [file tail $FichierTFA]]} {
set FichierTFA "$RepertoireDuGenome/prottfa/$FichierTFA"
}
set NomDeLaProteine [file tail $FichierTFA]
set FichierBlast "[RepertoireDeTravail]/$NomDeLaProteine.tblastn"
if { ! [file exists $FichierBlast]} {
set CommandeTBlastN "exec blastall \
-p tblastn \
-i $FichierTFA \
-o $FichierBlast \
-d $NomDeLaBanque \
-v 500 \
-K 0 \
-b 500 \
-e 10.0 \
-F F"
eval $CommandeTBlastN
}
set MonReflet [lindex [ChaqueProteineDuTBlastN $FichierBlast "AvecLaSeq"] 0]
set MesTraits [split $MonReflet "\t"]
set Debut [lindex $MesTraits 9]
set Fin [lindex $MesTraits 10]
set Subject [lindex $MesTraits 11]
set Query [QueLaSequence [ContenuDuFichier $FichierTFA]]
if {[string range $Query 1 end] != [string range $Subject 1 end]} {
Espionne $NomDeLaProteine
Espionne $Query
Espionne $Subject
return "$Debut $Fin :Erreur:$Query:$Subject"
}
return "$Debut $Fin"
}
proc QueLaSequence TFA {
set Seq [join [lrange [split $TFA "\n"] 1 end] ""]
regsub -all {[ 0-9\.]} $Seq "" Seq
return $Seq
}
proc LesLongueurs FichierTFAs {
foreach Sale [LesLignesDuFichier $FichierTFAs] {
if {[regexp "^>" $Sale]} {
scan $Sale "%s" Access
if {[info exists LongSale]} {
puts "$LongSale $LongPropre $Access"
}
set LongSale 0
set LongPropre 0
}
regsub -all -nocase {[^a-z]} $Sale "" Propre
incr LongSale [string length $Sale]
incr LongPropre [string length $Propre]
}
puts "$LongSale $LongPropre $Access"
exit
}
proc DeDoubleLesSequencesDuTFAs {FichierTFAs {Sortie ""} {Nice ""}} {
#rR Le NiceHomosapiens c'est pour avoir une jolie definition pour la banque pour SM2PH
foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "@@@"] {
if {[regexp {@@@} $Access]} { continue }
if {[info exists DejaVu($Access)]} { continue }
set DejaVu($Access) $Access
set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
if {[regexp -nocase "Nice" $Nice]} {
regsub -all {[\| ]+} $TFA " " TFA
}
if {[regexp -nocase "NiceHomosapiens" $Nice]} {
set LeNice {}
foreach Ligne [split $TFA "\n"] {
regsub -all {(>[^ ]+ )[0-9]+ } $Ligne "\\1Homo sapiens " Ligne
regsub -all { \[Homo.*} $Ligne "" Ligne
lappend LeNice $Ligne
}
set TFA [join $LeNice "\n"]
}
lappend LaSortie $TFA
}
if {$Sortie=="GetList"} { return $LaSortie }
if {$Sortie=="GetText"} { return [join $LaSortie "\n"] }
return [SauveLesLignes $LaSortie dans $Sortie]
}
proc ExploseLeTFAs {FichierTFAs {Dir ""} {Nommage ""} {Ext ""}} {
if {$Dir ==""} { set Dir "." }
if {$Nommage==""} { set Nommage "UseFirstWord" }
regsub {^\.+} $Ext "." Ext
set LesCrees {}
foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "" "ForceAccessFirst"] {
set Nom $Access
regsub -all -nocase {[^a-z0-9\-\_\+]} $Nom "_" Nom
set Fic "$Dir/$Nom$Ext"
set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
lappend LesCrees [Sauve $TFA dans $Fic]
}
return $LesCrees
}
proc QueLaSequenceDuTFAs {FichierTFAs AccessDemande {DontMemorize ""} {CarRedon ""} {ForceAccessFirst ""} {AllowDigitOnly ""}} {
set TFA [LaSequenceDuTFAs $FichierTFAs $AccessDemande $DontMemorize $CarRedon $ForceAccessFirst $AllowDigitOnly]
if {[regexp -nocase {list.*acc} $AccessDemande]} { return $TFA }
return [QueLaSequenceDuTexteTFA $TFA]
}
proc LaSequenceDuTFAs {FichierTFAs AccessDemande {DontMemorize ""} {CarRedon ""} {ForceAccessFirst ""} {AllowDigitOnly ""}} {
global LesSequencesDuTFAs
if {$AccessDemande=="UnSet"} {
if {[info exists LesSequencesDuTFAs($FichierTFAs)]} { unset LesSequencesDuTFAs($FichierTFAs) }
return ""
}
if {$DontMemorize=="DontMemorize"} { set DontMemorize 1 } else { set DontMemorize 0 }
if {$CarRedon==""} { set CarRedon "_" }
if {[string equal -nocase $AllowDigitOnly "AllowDigitOnly"]} {
set AllowDigitOnly 1
} else {
set PrefixIfDigitOnly $AllowDigitOnly
if {$PrefixIfDigitOnly==""} { set PrefixIfDigitOnly "n" }
set AllowDigitOnly 0
}
set ForceAccessFirst [string equal -nocase $ForceAccessFirst "ForceAccessFirst"]
regsub "\:" $AccessDemande "_" AccessDemande
Wup "Loads the sequence corresponding to Access from a multiple tfa file (can be a blast database)"
Wup "Not sure that it works well if wrong '>b:id access'"
if {[regexp -nocase {list.*acc} $AccessDemande]} { set AccessDemande "LaListeDesAccess" }
if {[info exists LesSequencesDuTFAs($FichierTFAs,$AccessDemande)]} {
return [set LesSequencesDuTFAs($FichierTFAs,$AccessDemande)]
}
if {[info exists LesSequencesDuTFAs($FichierTFAs)]} {
return ""
}
set nIeme 1
set Trouve 0
set I 0
#rR attention dans le temps je considerais le BanqueId comme etant du style SPT:ABCDEF
#rR Maintenant c'est plutot du style SYNT_HUMAN ...
#rR Du coup dans ce qui suit, ou on s'attend soit a trouver >SYNTH_HUMAN Q12345 soit >Q12345
#rR dans le premier cas on vuet avoir les deux ...
#rR et pour les PDB c'est on a en general >PDB:1y18_F et pas d'access
#rR pour je ne sais plus quelle raison j'ai remplace les : par _
foreach Ligne [LesLignesDuFichier $FichierTFAs] {
if { ! [regexp -nocase {[\-\.\*a-z0-9_>]} $Ligne]} { continue }
if { [regexp {^#} $Ligne]} { continue }
if {[regexp "^>" $Ligne]} {
incr I
if {$DontMemorize && $Trouve} { break }
regsub {^> *} $Ligne "" Ligne
set AccessLu ""
scan $Ligne "%s %s" BanqueId AccessLu
set Meme 0
if {$ForceAccessFirst || [regexp -nocase {^PDB\:} $BanqueId] || [regexp "|" $BanqueId]} {
set AccessLu $BanqueId
set Meme 1
} else {
# if { ! [regexp -nocase {[a-z0-9_]+\:[a-z0-9_]+} $BanqueId] } { Espionne coucou; set AccessLu $BanqueId }
}
regsub {\:} $BanqueId "_" Banque_Id
regsub {\:} $AccessLu "_" Access_Lu
if { ! [regexp -nocase {[a-z0-9]} $AccessLu]} { set Access_Lu $Banque_Id } ;#rR 2014/01/07 car il n'y a plus de Access
set Access $Access_Lu
#rR ATTENTION on rajoute PrefixIfDigitOnly si y a que des chiffres car y avait clustal (?) qui se plante !
if { ! $AllowDigitOnly && ! [regexp -nocase {[a-z_]} $Access_Lu]} {
set Access "$PrefixIfDigitOnly$Access_Lu"
}
set AccessTmp $Access
set nIeme 1
while {[info exists DejaVu($Access)]} { set Access "$AccessTmp$CarRedon[incr nIeme]" }
if {$Meme} { set BanqueId $Access }
set DejaVu($Access) 1
if {$DontMemorize && $Access!=$Access_Lu} { continue }
if {$Access!=$Access_Lu && ! [regexp -nocase {[^a-z\:_0-9]} $Access_Lu]} { regsub "$Access_Lu" $Ligne $Access Ligne }
set LesSequencesDuTFAs($FichierTFAs,$Access) ">$Ligne"
if {$Banque_Id!=$Access && ! [info exists LesSequencesDuTFAs($FichierTFAs,$Banque_Id)]} {
set LesSequencesDuTFAs($FichierTFAs,$Banque_Id) ">$Ligne"
}
lappend LesSequencesDuTFAs($FichierTFAs,LaListeDesAccess) $Access
continue
}
if {$DontMemorize && $Access!=$Access_Lu} { continue }
set Trouve 1
append LesSequencesDuTFAs($FichierTFAs,$Access) "\n$Ligne"
if {$Banque_Id!=$Access && ! [info exists LesSequencesDuTFAs($FichierTFAs,$Banque_Id)]} {
append LesSequencesDuTFAs($FichierTFAs,$Banque_Id) "\n$Ligne"
}
}
if {$DontMemorize} {
if {[info exists LesSequencesDuTFAs($FichierTFAs,$AccessDemande)]} {
return [set LesSequencesDuTFAs($FichierTFAs,$AccessDemande)]
} else {
return ""
}
}
set LesSequencesDuTFAs($FichierTFAs) "SontChargees"
return [LaSequenceDuTFAs $FichierTFAs $AccessDemande]
}
proc RetireUnOrgaDansTFAs {Orga Source Destination} {
set Ignore 0
foreach Ligne [LesLignesDuFichier $Source] {
if {[regexp "^>$Orga" $Ligne]} {
set Ignore 1
continue
}
if {[regexp "^>" $Ligne]} { set Ignore 0 }
if {$Ignore} { continue }
lappend LesNouveaux $Ligne
}
return [SauveLesLignes $LesNouveaux dans $Destination]
}
proc LesBornesDeGlimmer {{NomNumeroDuDernierExistant ""} {FichierGlimmer ""}} {
global RepertoireDuGenome
FaireLire "Attention, Glimmer 1.04 lit result.out\nGlimmer 2.0 lit result.coord"
set NePasPrendreLesDouteux 0
if {$NomNumeroDuDernierExistant==""} {
set Prefixe [PreFixe]
set DernierNumero "0000"
} else {
regsub -all {[0-9]} $NomNumeroDuDernierExistant "" Prefixe
regsub -all -nocase {[a-z_]} $NomNumeroDuDernierExistant "" ChaineDernierNumero
if {$ChaineDernierNumero==""} { set ChaineDernierNumero 0 }
scan $ChaineDernierNumero "%d" DernierNumero
}
if {$FichierGlimmer==""} {
set FichierGlimmer "$RepertoireDuGenome/glimmer/result.coord"
}
while { ! [file exists $FichierGlimmer]} {
if {[OuiOuNon "I can't find the Glimmer output\n$FichierGlimmer\n\Do I run Glimmer ?"]} {
Glimmer
} else {
return {}
}
}
set OnAttendQueCaVienne [regexp "Putative Genes" [ContenuDuFichier $FichierGlimmer]]
set LesBornesDeGlimmer {}
foreach Ligne [LesLignesDuFichier $FichierGlimmer] {
Espionne $Ligne
if {[regexp "Putative Genes" $Ligne]} {
set OnAttendQueCaVienne 0
continue
} else {
if {$OnAttendQueCaVienne} { continue }
}
if {$NePasPrendreLesDouteux && [regexp {\[} $Ligne]} { continue }
scan $Ligne "%d %d %d" Numero Debut Fin
incr Numero $DernierNumero
set Nom [format "%s%[FormatDesNumerosPourCollection]" $Prefixe $Numero]
if {$Debut < $Fin} {
set Orient "F"
} else {
set Orient "R"
set Toto $Debut
set Debut $Fin
set Fin $Toto
}
set Long [expr $Fin-$Debut+1]
if {$Long>100000} { continue }
set Frame [string toupper [NomDeLaFrame [expr $Debut%3] $Orient]]
lappend LesBornesDeGlimmer "$Nom $Debut $Fin $Orient"
}
return $LesBornesDeGlimmer
}
proc LaSequenceConvertieSiOnVeut {LaSequence OnVeutEMBL Access} {
if { ! $OnVeutEMBL } { return $LaSequence }
set Format [FormatDeLaSequence_l $LaSequence]
if {$Format == "embl"} {
return $LaSequence
} else {
return [split [SequenceFormatEMBL_l $LaSequence $Access $Format] "\n"]
}
}
proc EstUnBonAccess Access {
global Commandes
if { ! [regexp {[a-zA-Z0-9_]} $Access] } { return 0 }
if { [string length $Access] > 70 } { return 0 }
Warne "J'examine $Access"
set NombreDeSequencesOK [FetchTest $Access]
return $NombreDeSequencesOK
}
proc QueryDeLaLigne {LigneQuery {CreateIt ""} {PossiblePAB ""}} {
global RepertoireDuGenome
global CreateQueryDeLaLigne
if {$CreateIt=="CreateIt"} {
set CreateIt 1
} elseif {$CreateIt=="DoNotCreateIt"} {
set CreateIt 0
} else {
if {[info exists CreateQueryDeLaLigne]} {
set CreateIt $CreateQueryDeLaLigne
} else {
set CreateIt 1
}
}
Wup "Tries to find the query then returns the file name. If not returns the name only"
set IndexBlanc [string first " " $LigneQuery]
set LigneQuery [string trim [string range $LigneQuery $IndexBlanc end]]
#rR 2018/11/06
if {[regexp {^([^\|]+\|[^\|]+\|[^ ]+)( |$)} $LigneQuery Match QueryTrouve]} {
#rR tant pis je ne cherche pas à creer un fichier puisqu'on rend sp|machin|chose
return $QueryTrouve
}
if { [regexp -indices {[, :\|]} $LigneQuery IndexesFin] } {
set IndexFin [expr [lindex $IndexesFin 0]-1]
} else {
set IndexFin "end"
}
set Query [string trim [string range $LigneQuery 0 $IndexFin]]
Wup "Le TryQuery suivant etait pour aider Julie a trouver les bons fichiers"
foreach TryQuery [list \
"$Query" \
"$RepertoireDuGenome/../casimir/prottfa/[file tail $Query]" \
"[RepertoireDeTravail]/[file tail $Query]" \
"$RepertoireDuGenome/nuctfa/[file tail $Query]" \
"$RepertoireDuGenome/prottfa/[file tail $Query]"] {
if { [file exists $TryQuery] } {
return $TryQuery
}
}
if {$PossiblePAB!="" && [Alias $PossiblePAB]==$Query} {
set Query $PossiblePAB
}
if { ! $CreateIt} { return $Query }
set SequenceQuery [SequenceDesBanquesVite $Query]
if {$SequenceQuery!=""} {
set TmpQuery [Sauve $SequenceQuery dans "[RepertoireDeTravail]/[file tail $Query]"]
return $TmpQuery
}
return $Query
}
proc AccessDUneLigneBlast {Ligne {Nom ""}} {
global RepertoireDuGenome
Wup "Certains blast ont ! entre Access0 et Access1"
regsub "!" $Ligne " " Ligne
scan $Ligne "%s %s" Access0 Access1
if {[regexp {^AFF[0-9]{5}$} $Access0]} {
if {[file exists "$RepertoireDuGenome/../AffyHS/nucembl/$Access0"]} {
return "$RepertoireDuGenome/../AffyHS/nucembl/$Access0"
}
}
if {[regexp "ClonV:" $Access0]} {
set Vec [lindex [split $Access0 ":"] 1]
if {[file exists "$RepertoireDuGenome/vecteurs/$Vec"]} {
return "$RepertoireDuGenome/vecteurs/$Vec"
}
}
if {[regexp "PABY:" $Access0]} {
set PAB [lindex [split $Access0 ":"] 1]
if {[file exists "$RepertoireDuGenome/../casimir/protembl/$PAB"]} {
return "$RepertoireDuGenome/../casimir/protembl/$PAB"
}
}
if {[regexp -nocase "PAE:" $Access0]} {
set PAE [lindex [split $Access0 ":"] 1]
if {[file exists "$RepertoireDuGenome/../Pyrobac/protembl/$PAE"]} {
return "$RepertoireDuGenome/../Pyrobac/protembl/$PAE"
}
}
if {[regexp -nocase "PFUR:" $Access0]} {
set PFUR [lindex [split $Access0 ":"] 1]
if {[file exists "$RepertoireDuGenome/../Pfuriosus/protembl/$PFUR"]} {
return "$RepertoireDuGenome/../Pfuriok/protembl/$PFUR"
}
}
if {[regexp "PFUR:" $Access0]} {
set PFOK [lindex [split $Access0 ":"] 1]
if {[file exists "$RepertoireDuGenome/../Pfuriok/protembl/$PFOK"]} {
return "$RepertoireDuGenome/../Pfuriok/protembl/$PFOK"
}
}
if { ! [info exists Access1]} { return $Access0 }
Wup "Les copains"
if { $Nom != "" && $Access1 != "" && [file exists "$RepertoireDuGenome/copains/$Nom/$Access1"]} {
return "$Access1"
}
if { $Access1 != "" && [FetchTest "protein:$Access1"]} {
return "protein:$Access1"
}
if { $Access1 != "" && [FetchTest "$Access1"]} {
return "$Access1"
}
return $Access0
}
proc Fetche Access {
global RepertoireDuGenome
global Commandes
LogWscope "Dans Fetche $Access"
return [SequenceDesBanques $Access]
if {[file exists $Access]} { return [ContenuDuFichier $Access] }
if {[regexp "^PAB" $Access] && [file exists "$RepertoireDuGenome/../casimir/protembl/$Access"]} {
return [ContenuDuFichier "$RepertoireDuGenome/../casimir/protembl/$Access"]
}
if {[regexp {^AFF[0-9]{5}$} $Access] && [file exists "$RepertoireDuGenome/../AffyHS/nucembl/$Access"]} {
return [ContenuDuFichier "$RepertoireDuGenome/../AffyHS/nucembl/$Access"]
}
if {[regexp {PAE[0-9]+} $Access] && [file exists "$RepertoireDuGenome/../Pyrobac/protembl/$Access"]} {
return [ContenuDuFichier "$RepertoireDuGenome/../Pyrobac/protembl/$Access"]
}
if {[regexp "PFUR" $Access] && [file exists "$RepertoireDuGenome/../Pfuriosus/protembl/$Access"]} {
return [ContenuDuFichier "$RepertoireDuGenome/../Pfuriosus/protembl/$Access"]
}
if {[regexp "PFOK" $Access] && [file exists "$RepertoireDuGenome/../Pfuriok/protembl/$Access"]} {
return [ContenuDuFichier "$RepertoireDuGenome/../Pfuriok/protembl/$Access"]
}
if { ([YaPABenDebutDe $Access] || \
[regexp "/[ExpressionReguliereDesPABs]$" $Access]) && \
[file exists "$RepertoireDuGenome/prottfa/[file tail $Access]"]} {
return [ContenuDuFichier "$RepertoireDuGenome/prottfa/[file tail $Access]"]
}
if { [regexp {^TROU[0-9]+[A-F]$} $Access] || \
[regexp "/[ExpressionReguliereDesPABs]\[A-F\]$" $Access] } {
return [ContenuDuFichier "$RepertoireDuGenome/trousprottfa/[file tail $Access]"]
}
if { [regexp {^TROU[0-9]+N$} $Access] || \
[regexp "/[ExpressionReguliereDesPABs]N$" $Access] } {
return [ContenuDuFichier "$RepertoireDuGenome/nuctfa/[file tail $Access]"]
}
if {[regsub -- {_$} $Access {} AccessTronque] && \
[file exists "$RepertoireDuGenome/tmpdir/$AccessTronque"]} {
return [ContenuDuFichier "$RepertoireDuGenome/tmpdir/$AccessTronque"]
}
if {[file exists "$RepertoireDuGenome/prrpgcgs/$Access"]} {
return [ContenuDuFichier "$RepertoireDuGenome/prrpgcgs/$Access"]
}
if {[file exists "$RepertoireDuGenome/tmpdir/$Access"]} {
return [ContenuDuFichier "$RepertoireDuGenome/tmpdir/$Access"]
}
if {[file exists "$RepertoireDuGenome/tmpdir/[string tolower $Access]"]} {
return [ContenuDuFichier "$RepertoireDuGenome/tmpdir/[string tolower $Access]"]
}
if {[file exists $Access]} {
return [ContenuDuFichier $Access]
}
if {[EstUnBonAccess $Access]} {
return [FetchCat $Access]
}
if {[regsub -- {_$} $Access {} AccessTronque]} {
return [Fetche $AccessTronque]
}
if { ! [regexp {[:/]} $Access]} {
return [Fetche ":$Access"]
}
if { [regexp {[:]} $Access] && ! [regexp "protein" $Access] } {
regsub -- {[a-zA-Z_^:]*:} $Access "protein:" AccessDansBanqueGCG
return [Fetche "$AccessDansBanqueGCG"]
}
return ""
}
proc GrosGetz {Fichier} {
set LesAccess [LesLignesDuFichier $Fichier]
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
set MoiAussi($ACCESS) 1
}
set Accesses [join $LesAccess "|"]
# Espionne [QuestionDeScience QuidSeq "QuidOSsOfACs $Accesses"]
# exit
set CommandeGetz "getz -e \"\\\[\{swissprot sptrembl\}-acc: $Accesses\\\]\""
set Texte [eval exec $CommandeGetz]
set LaSeq {}
foreach Ligne [split $Texte "\n"] {
if {[regexp "^AC " $Ligne]} {
regsub -all "\;" $Ligne " " Ligne
set LesAccessRecus [split $Ligne " "]
set AccessOK "Inconnu"
foreach Access $LesAccessRecus {
set ACCESS [string toupper $Access]
if {[info exists MoiAussi($ACCESS)]} { set AccessOK $Access }
}
}
if {[regexp "^//" $Ligne]} {
lappend LaSeq $Ligne
set Seq [join $LaSeq "\n"]
lappend LesSeqs $Seq
set MaSeq($AccessOK) $Seq
set LaSeq {}
} else {
lappend LaSeq $Ligne
}
}
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
Espionne "\n$Access"
if { ! [info exists MaSeq($ACCESS)]} {
Espionne "$Access ................................................ non trouve"
} else {
Espionne [set MaSeq($ACCESS)]
}
}
exit
}
proc Getz {Access args} {
set Tous [regexp {\|} $Access]
set LesOptions {}
if {$args=={}} {
# set Banques "\{swissprot sptrembl\}"
set Banques "\{uniprot\}"
} else {
set LesBanques {}
set YaOption 0
foreach Banque $args {
if {$YaOption} {
set YaOption 0
lappend LesOptions $Banque
continue
}
if {[regexp {^\-} $Banque]} {
set YaOption 1
lappend LesOptions $Banque
continue
}
set Banque [string tolower $Banque]
if {[info exists DejaVu($Banque)]} { continue }
set DejaVu($Banque) 1
lappend LesBanques "$Banque"
}
set Banques "\\{[join $LesBanques " "]\\}"
}
if {$LesOptions=={}} {
set Options "-e"
} else {
set Options [join $LesOptions " "]
}
if {[regexp -nocase "Decrypthon" $Banques]} {
set LesClefs [list "DR" "AccNumber" "ID" "DBxref"]
} else {
set LesClefs [list "AccNumber" "ID" "DBxref"]
}
foreach Clef $LesClefs] {
if {$Clef=="DBxref" && ! [regexp -nocase {[A-Z]{3}[0-9]{4,}} $Access]} { return "" }
if {$Clef=="DBxref"} { set Etoile "*" } else { set Etoile "" }
set Commande "getz $Options \"\\\[$Banques-$Clef: $Access$Etoile\\\]\""
if {[info exists GetzOut]} { unset GetzOut }
catch {set GetzOut [eval exec $Commande]} Message
if {[info exists GetzOut] && [regexp -nocase {[a-z]} $GetzOut]} {
if {$Tous || [regexp -nocase "Decrypthon" $Banques]} {
return $GetzOut
} else {
return [UnSeulGetz $GetzOut]
}
}
}
return ""
}
proc SequenceFormatEMBLDuFichierTFA {Fichier {NomDeBapteme ""} {AccessAsGN ""} {OsStartsDe ""} {Premiere ""} {ClearSequence ""}} {
set Format "tfa"
return [SequenceFormatEMBL [ContenuDuFichier $Fichier] $NomDeBapteme $Format $AccessAsGN $OsStartsDe $Premiere $ClearSequence]
}
proc SequenceFormatEMBLDuFichier {Fichier {NomDeBapteme ""} {Format ""} {AccessAsGN ""} {OsStartsDe ""} {Premiere ""} {ClearSequence ""}} {
return [SequenceFormatEMBL [ContenuDuFichier $Fichier] $NomDeBapteme $Format $AccessAsGN $OsStartsDe $Premiere $ClearSequence]
}
proc SequenceFormatEMBL_l {Liste {NomDeBapteme ""} {Format ""} {AccessAsGN ""} {OsStartsDe ""} {Premiere ""} {ClearSequence ""}} {
return [SequenceFormatEMBL [join $Liste "\n"] $NomDeBapteme $Format $AccessAsGN $OsStartsDe $Premiere $ClearSequence]
}
proc SequenceFormatEMBL {Texte {NomDeBapteme ""} {Format ""} {AccessAsGN ""} {OsStartsDe ""} {Premiere ""} {ClearSequence ""}} {
if {$Texte==""} { return "" }
if { ! [regexp "\n" $Texte] && [file exists $Texte]} {
set Texte [ContenuDuFichier $Texte]
}
if {$AccessAsGN==""} { set AccessAsGN "Ask" }
if {$OsStartsDe==""} { set OsStartsDe "Ask" }
if {$ClearSequence==""} { set ClearSequence "ClearSequence" }
set ClearSequence [string equal -nocase $ClearSequence "ClearSequence"]
if {$Format==""} { set Format [FormatDeLaSequence $Texte]}
if {$Format=="embl"} { return $Texte }
if {[string equal -nocase $Format "tfa"]} {
set LesLignesTFA [split $Texte "\n"]
if {$Premiere==""} { set Premiere [lindex $LesLignesTFA 0] }
#rR là on joue subtilement sur les Majuscule minuscule de l'OS situe entre
#rR ID AC Genre espece definition ou
#rR ID Genre espece definition
set IdMayBe ""
set AcMayBe ""
set OsMayBe ""
if {[regexp {^>([A-Za-z0-9_\-\.\:]+) ([A-Za-z0-9_\-\.\:]+) ([A-Z][a-z]+) ([a-z\.]+)} $Premiere Match Id Ac Ge Es]} {
set IdMayBe $Id
set AcMayBe $Ac
set OsMayBe "$Ge $Es"
}
if {[regexp {^>([A-Za-z0-9_\-\.\:]+) ([A-Z][a-z]+) ([a-z\.]+)} $Premiere Match Id Ge Es]} {
set IdMayBe $Id
set AcMayBe $Id
set OsMayBe "$Ge $Es"
}
#rR rajouté 2014/06/29 pour prendre en compte OS=Home_sapiens_strain_bidule GN=Pax2 TAXID=9606
#rR mais attention Genre espece peut quand meme etre devant la definition
set AEnleverDeDE {}
if {[regexp {OS=(.*?) [A-Z]+=} $Premiere Match FullOs] || [regexp {OS=(.*?)$} $Premiere Match FullOs]} {
lappend AEnleverDeDE "OS=$FullOs"
regsub -all "_" $FullOs " " FullOs
set OsMayBe [lrange [split $FullOs " "] 0 1] ;#rR on le positionne pour pouvoir l'enlever
}
if {[regexp {GN=(.*?) [A-Z]+=} $Premiere Match GeneName] || [regexp {GN=(.*?)$} $Premiere Match GeneName]} {
lappend AEnleverDeDE "GN=$GeneName"
set BestGN "Name=$GeneName;"
}
if {[regexp {TAXID=(.*?) [A-Z]+=} $Premiere Match TaxId] || [regexp {TAXID=(.*?)$} $Premiere Match TaxId]} {
lappend AEnleverDeDE "TAXID=$TaxId"
set BestOX "NCBI_TaxID=$TaxId;"
if {[TaxClass "IsAlreadyLoaded"]} {
set OC [TaxClass $TaxId "Name"]
set OC [string trim $OC " ;"]
if {$OC!=""} { set BestOC "$OC." }
}
}
scan $Premiere "%s" Access
regsub ">" $Access "" Access
regsub {[^ ]+ } $Premiere "" Definition
#rR pour traiter >sp|P12345|Bidule_HUMAN Definition...
set ID ""
if {[regexp -nocase {^([a-z\:]+)\|([a-z0-9_]+)\|([a-z0-9_]+)$} $Access Match BA AC ID]} {
if {[regexp -nocase "pdb:" $BA]} { set AC $BA$AC }
set Premiere ">$AC $ID $Definition"
set Access $AC
}
if {[regexp {\|} $Access]} {
set LesPossibles [split $Access "|"]
set Bon $Access
foreach Possible $LesPossibles {
if { ! [regexp -nocase {^refseq} $Possible]} { set Bon $Possible; break }
}
set Access $Bon
}
set OS ""
# Espionne "$Premiere $Access"
if {[EstUnPAB $Access]} {
set DE $Definition
set GN ""
set OS ""
} else {
if {[string equal -nocase $AccessAsGN "Ask"]} {
set AccessAsGN [OuiOuNonMemo "Do I use the access as GeneName GN ?" 0]
} else {
set AccessAsGN [string equal -nocase $AccessAsGN "AccessAsGn"]
}
set GN ""
if {$AccessAsGN} { set GN $Access }
set Definition [string trim $Definition]
if {[string equal -nocase $OsStartsDe "Ask"]} {
set OsStartsDe [OuiOuNonMemo "Do all following definitions always start with the organism name ?" 0]
} else {
set OsStartsDe [string equal -nocase $AccessAsGN "OsStartsDe"]
}
if {$Definition==""} {
set DE ""
} else {
set DE "$Definition"
}
set GE ""
if {$AccessAsGN} {
set GE "$Access"
}
if {$OsStartsDe} {
set Genre ""
set Espece ""
set OS ""
scan $DE "%s %s" Genre Espece
if {[regexp {^[A-Z][a-z]+ [a-z]+$} "$Genre $Espece"]} {
set OS "$Genre $Espece"
regsub "$Genre +$Espece +" $DE "" DE
}
}
if {[regexp {\.{2,} *$} $DE]} { regsub {\.{2,} *$} $DE "" DE }
if {$OS=="" && [regexp {\[([^\]]+)\]} $DE Match OsPossible]} {
set Genre ""
set Espece ""
scan $OsPossible "%s %s" Genre Espece
if {$Espece!=""} { set OS "$Genre $Espece" }
}
}
if {$ID==""} { set ID $Access }
foreach T $AEnleverDeDE {
regsub -all {\(} $T "\\(" T
regsub -all {\)} $T "\\(" T
regsub -all {\+} $T "\\+" T
regsub -all {\-} $T "\\-" T
regsub -all {\\} $T "." T
catch {regsub $T $DE "" DE} ;#rR 2014/07/30 car ça peut planter
}
#rR rajout 2014/06/19 ..................... pour OrthoInspector
if {$OS=="" && $OsMayBe!=""} {
set OS $OsMayBe
regsub "^$AcMayBe $OS " $DE "" DE
regsub "^$OS " $DE "" DE
if {$IdMayBe!=""} { set ID $IdMayBe }
if {$AcMayBe!=""} { set Access $AcMayBe }
}
#rR rajout 2014/06/29 ..................... il peut quand meme y avor un OS devant ... donc on garde ci-dessus
if {[info exists FullOs]} { set OS $FullOs }
if {[info exists BestGN]} { set GN $BestGN }
if {[info exists BestOX]} { set OX $BestOX } else { set OX "" }
if {[info exists BestOC]} { set OC $BestOC } else { set OC "" }
regsub -all " +" $DE " " DE
set DE [string trim $DE]
#rR attention si NomDeBapteme est non vide on l'utilise a la place de ID (qui est garde depuis 2015/01/13)
set RealID ""
if {$NomDeBapteme!=""} {
if {$ID!=$Access} { set RealID $ID }
set ID $NomDeBapteme
}
set Header ""
append Header "ID $ID;$RealID cree par Gscope avec tfa."
append Header "\nAC $Access"
if {$GN!=""} { append Header "\nGN $GN" }
if {$DE!=""} { append Header "\nDE $DE" }
if {$OS!=""} { append Header "\nOS $OS" }
if {$OC!=""} { append Header "\nOC $OC" }
if {$OX!=""} { append Header "\nOX $OX" }
if {$ClearSequence} {
regsub -all {[ 0-9/\n\t]} [join [lrange $LesLignesTFA 1 end] ""] "" Sequence
} else {
set Sequence [join [lrange $LesLignesTFA 1 end] ""]
}
set EMBL "$Header\n[QueSequenceFormatEMBL $Sequence AvecSQ]\n"
return $EMBL
}
if {$Format=="gcg"} {
set LesLignesGCG [split $Texte "\n"]
set ResteLaSequence 0
foreach Ligne $LesLignesGCG {
if {$ResteLaSequence} {
lappend LaSequence $Ligne
continue
}
if {[regexp {[^.]\.\.[ \t]*$} $Ligne]} {
set ResteLaSequence 1
continue
}
if {[regexp {^[A-Z][A-Z] } $Ligne]} {
lappend lEmbl $Ligne
set DerniereLigne $Ligne
}
}
set Sequence [join $LaSequence]
regsub -all {[ 0-9/\n\t]} $Sequence "" Sequence
if {[regexp "^SQ" $DerniereLigne]} {
lappend lEmbl [QueSequenceFormatEMBL $Sequence "SansSQ"]
} else {
lappend lEmbl [QueSequenceFormatEMBL $Sequence "AvecSQ"]
}
return [join $lEmbl "\n"]
}
if {$Format=="gcgmaybe"} {
set LesLignesGCG [split $Texte "\n"]
set AttendPP 1
foreach Ligne $LesLignesGCG {
if {$AttendPP} {
if {[regexp {[^.]\.\.[ \t]*$} $Ligne]} {
set AttendPP 0
}
continue
}
if { ! [regexp -nocase {[A-Z]} $Ligne]} { continue }
lappend LaSequence $Ligne
}
set Sequence [join $LaSequence]
regsub -all {[ 0-9/\n\t]} $Sequence "" Sequence
if {$NomDeBapteme==""} {
set Access "Unknown"
} else {
set Access $NomDeBapteme
}
set Header "ID $Access; cree par Gscope avec gcgmaybe.\nAC $Access"
set EMBL "$Header\n[QueSequenceFormatEMBL $Sequence AvecSQ]\n\\"
return $EMBL
}
}
proc FormatDeLaSequenceDuFichier Fichier {
return [FormatDeLaSequence [ContenuDuFichier $Fichier]]
}
proc FormatDeLaSequence_l Sequence {
return [FormatDeLaSequence [join $Sequence "\n"]]
}
proc FormatDeLaSequence Sequence {
Wup "returns tfa tfas embl gcg gcgmaybe nucbrut protbrut or Inconnu"
regsub {!![NA]A_SEQUENCE 1.0\n} $Sequence "" Sequence
if {[set iC [string first ">" $Sequence]]==0} {
if {[set iDL [string first "\n" $Sequence 1]]>1} {
if {[string first ">" $Sequence $iDL]>0} { return "tfas" } else {return "tfa"}
}
}
if {[regexp "^ID " $Sequence]} {
if {[regexp {[^p\.]\.\.[ \t]*\n} $Sequence]} {
return "gcg"
}
return "embl"
}
if {[regexp {[^\.]\.\.[ \t]*\n} $Sequence]} { return "gcgmaybe" }
if {[regexp -nocase {[^a-zA-Z0-9\.\n\t \*]} $Sequence]} { return "Inconnu" }
if {[regexp -nocase {[^ATGCX0-9\.\n\t \*]} $Sequence]} { return "protbrut" }
return "nucbrut"
}
proc FastaLineWidth {{W ""}} {
global FastaLineWidth
set Default 60
if {$W!=""} { set FastaLineWidth $W }
if {[regexp -nocase "Default" $W]} { set FastaLineWidth $Default }
if { ! [info exists FastaLineWidth]} { set FastaLineWidth $Default }
return $FastaLineWidth
}
proc SequenceFormatBrut_l Seq {
return [SequenceFormatBrut [join $Seq "\n"]]
}
proc AllowIllegalCharactersInTFA {{Valeur ""}} {
global AllowIllegalCharactersInTFA
if { $Valeur=="ResetAllValues"} {
if {[info exists AllowIllegalCharactersInTFA]} { unset AllowIllegalCharactersInTFA }
set Valeur 0
}
if { ! [info exists AllowIllegalCharactersInTFA]} {
set AllowIllegalCharactersInTFA(Level) 1
set AllowIllegalCharactersInTFA(1) 0
}
if {[regexp "Previous" $Valeur]} {
if {$AllowIllegalCharactersInTFA(Level)>1} { incr AllowIllegalCharactersInTFA(Level) -1 }
return [AllowIllegalCharactersInTFA]
}
if {$Valeur!=""} {
if {[regexp -nocase {[1YVA]} $Valeur]} { set Valeur 1 } else { set Valeur 0 }
incr AllowIllegalCharactersInTFA(Level)
set AllowIllegalCharactersInTFA($AllowIllegalCharactersInTFA(Level)) $Valeur
}
return $AllowIllegalCharactersInTFA($AllowIllegalCharactersInTFA(Level))
}
proc SequenceFormatBrut {Seq {CarParLigne ""} {DoVerify ""}} {
global SequenceFormatBrutIn SequenceFormatBrutOut
if {$DoVerify==""} {
if { [AllowIllegalCharactersInTFA] } { set DoVerify "DoNotVerify" }
}
set DoVerify [expr ! [string equal -nocase $DoVerify "DoNotVerify"]]
if {[info exists SequenceFormatBrutIn] && $Seq==$SequenceFormatBrutIn} {
return $SequenceFormatBrutOut
}
set SequenceFormatBrutIn $Seq
if {$CarParLigne==""} { set CarParLigne [FastaLineWidth] }
if {$DoVerify} {
while {[regexp -nocase {\*$} $Seq]} { regsub {\*$} $Seq "" Seq }
if {[regexp -nocase {\*} $Seq]} {
if { ! [OuiOuNonMemo "Do I stop signaling when I found * ?" 0]} {
FaireLire "$Seq\n contains *\n I'll replace them with x."
}
regsub -all {\*} $Seq "X" Seq
}
if {[regexp "\~" $Seq]} { regsub -all "\~" $Seq "." Seq }
if {[regexp -nocase {[^0-9 \-\n\ta-z\.]} $Seq]} {
if { ! [OuiOuNonMemo "Do I stop signaling when I found illegal characters ?" 0]} {
FaireLire "$Seq\n contains illegal characters\n I'll remove them."
}
}
regsub -all -nocase {[^a-z\-\.]} $Seq "" Seq
}
if {$Seq == "" } { set SequenceFormatBrutOut "" ; return "" }
for {set i 0} {$i < [string length $Seq]} { incr i $CarParLigne} {
lappend ListeDesLignes [string range $Seq $i [expr $i+$CarParLigne-1]]
}
set SequenceFormatBrutOut [join $ListeDesLignes "\n"]
return $SequenceFormatBrutOut
}
proc SequenceFormatBrutduPAB Boite {
Wup "Takes the DNA, translates to AAs and returns lines of 60 AAs."
set Nom [Box $Boite nom]
set Debut [Box $Boite debut]
set Fin [Box $Boite fin]
set Orient [Box $Boite orient]
#set Long [expr $Fin-$Debut+1]
set SeqNuc [BoutADN $Debut $Fin $Orient]
set SeqPro [SeqNucToSeqPro $SeqNuc]
return [SequenceFormatBrut $SeqPro]
}
proc QueSequenceFormatEMBL_l {Seq {AvecSQ "AvecSQ"}} {
return [QueSequenceFormatEMBL [join $Seq "\n"] $AvecSQ]
}
proc TestQueSequenceFormatEMBL {} {
Espionne [QueSequenceFormatEMBL "\
METKGYHSLPEGLDMERRWGQVSQAVERSSLGPTERTDENNYMEIVNVSC\
VSGAIPNNSTQGSSKEKQELLPCLQQDNNRPGILTSDIKTELESKELSAT\
VAESMGLYMDSVRDADYSYEQQNQQGSMSPAKIYQNVEQLVKFYKGNGHR\
PSTLSCVNTPLRSFMSDSGSSVNGGVMRAIVKSPIMCHEKSPSVCSPLNM\
TSSVCSPAGINSVSSTTASFGSFPVHSPITQGTPLTCSPNAENRGSRSHS\
PAHASNVGSPLSSPLSSMKSSISSPPSHCSVKSPVSSPNNVTLRSSVSSP\
ANINNSRCSVSSPSNTNNRSTLSSPAASTVGSICSPVNNAFSYTASGTSA\
GSSTLRDVVPSPDTQEKGAQEVPFPKTEEVESAISNGVTGQLNIVQYIKP\
EPDGAFSSSCLGGNSKINSDSSFSVPIKQESTKHSCSGTSFKGNPTVNPF" "" AvecReperes]
}
proc QueSequenceFormatEMBL {Seq {AvecSQ ""} {AvecReperes ""}} {
if {$AvecSQ==""} { set AvecSQ "AvecSQ" }
set AvecReperes [string equal -nocase $AvecReperes "AvecReperes"]
Wup "Returns the EMBL format (lines of 6 groups of 10) from the string of AAs or NAs $Seq"
Wup "Removes . and -"
regsub -all -nocase {[^a-z]} $Seq "" Seq
set Long [string length $Seq]
set LesLignes {}
if {$AvecSQ == "AvecSQ"} {
if {[regexp -nocase {[MVLDEFHIKLPQRSVW]} $Seq Match]} {
set EnteteSQ "SQ SEQUENCE $Long AA;"
} else {
set EnteteSQ "SQ SEQUENCE $Long Bp;"
}
lappend LesLignes $EnteteSQ
}
set nRepere 1
set nDevant 9
set Repere [string repeat " " [expr $nDevant+1]]
set Ligne ""
for {set i 0} {$i < $Long} {incr i} {
if {$AvecReperes} { set Repere [format "%${nDevant}s " $nRepere] }
if {[expr $i%60 == 0]} {
if {$Ligne != ""} { lappend LesLignes $Ligne }
set Ligne $Repere
incr nRepere 60
}
if { ! [expr $i%60 == 0] && [expr $i%10 == 0]} {append Ligne " " }
append Ligne [string range $Seq $i $i]
}
if {[regexp -nocase {[a-z]} $Ligne]} { lappend LesLignes $Ligne }
set Tout [join $LesLignes "\n"]
return $Tout
}
proc QueSequenceFormatEMBLduPAB {Boite {AvecSQ "AvecSQ"}} {
Wup "Takes the DNA, translates in AAs and formates in EMBL"
set Nom [Box $Boite nom]
set Debut [Box $Boite debut]
set Fin [Box $Boite fin]
set Orient [Box $Boite orient]
set Long [expr $Fin-$Debut+1]
set SeqNuc [BoutADN $Debut $Fin $Orient]
set SeqPro [SeqNucToSeqPro $SeqNuc]
return [QueSequenceFormatEMBL $SeqPro $AvecSQ]
}
proc tfred {} {
set LLE [LaSequenceDesBanques GB_PR12:BC000249 BC000249 a OnVeutNucEMBL]
Espionne [SequenceFormatTFA_l $LLE "" ""]
exit
}
proc OsCanon Ligne {
global OsCanon
while { ! [regexp { +([A-Z][a-z\.]+ [a-z\.]+)( [a-z]* *)*$} $Ligne Match OS]} {
set Trouve 0
foreach OldOS [array names OsCanon] {
if { [set I [string last $OldOS $Ligne]]>10 } {
set Better [string range $Ligne 0 [expr $I-1]]
append Better $OsCanon($OldOS)
set Ligne $Better
set Trouve 1
break
}
}
if {$Trouve} { continue }
set Better [Entre $Ligne]
set I 0
foreach C [split $Ligne ""] {
if {[string index $Better $I]==$C} { incr I ; continue }
break
}
set NewOS [string range $Better $I end]
set OldOS [string range $Ligne $I end]
set OsCanon($OldOS) $NewOS
set Ligne $Better
}
regsub { +([A-Z][a-z]+ [a-z\.]+)( [a-z\.]* *)*$} $Ligne " OS=$OS" Ligne
return $Ligne
}
proc TestExtractPartsFromEMBL {} {
Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 0 2]
Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 3 3]
Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 2 3]
Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 26224 26224]
Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 26225 26225]
Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 26224]
Espionne [ExtractPartsFromEMBL ./uniprot_trembl_vertebrates.dat 26225]
exit
}
proc ExtractPartsFromEMBL {Fichier {I ""} {J ""}} {
global ExtractPartsFromEMBL
if {$I==""} { set I 0 }
if {$J==""} { set J 9999999 }
set LesParts {}
while {[info exists ExtractPartsFromEMBL]} {
if {$ExtractPartsFromEMBL(filename)!=$Fichier || $I=="close" || $ExtractPartsFromEMBL(Vu) >= $I} {
catch { close $ExtractPartsFromEMBL(f) }
unset ExtractPartsFromEMBL
if {$I=="close"} { return }
break
}
set f $ExtractPartsFromEMBL(f)
set Vu $ExtractPartsFromEMBL(Vu)
break
}
if { ! [info exists ExtractPartsFromEMBL]} {
set f [open $Fichier "r"]
set ExtractPartsFromEMBL(f) $f
set ExtractPartsFromEMBL(filename) $Fichier
set Vu -1
}
set Prends 0
set LeCourant {}
while {[gets $f Ligne]>=0} {
if {[regexp {^ID } $Ligne]} {
incr Vu
if {$J < $Vu} { break }
if {$Vu < $I } { continue }
set Prends 1
lappend LeCourant $Ligne
continue
}
if { ! $Prends } { continue }
lappend LeCourant $Ligne
if {[regexp "^//" $Ligne]} {
lappend LesParts [join $LeCourant "\n"]
set LeCourant {}
if {$J == $Vu} { break }
}
}
set ExtractPartsFromEMBL(Vu) $Vu
return $LesParts
}
proc testgz {} {
set File "toto.protein.gpff.gz"
if {[regexp {.+\.gz$} $File]} {Espionne "yes"}
}
proc ExtractPartsFromGenBank {Fichier {I ""} {J ""}} {
global ExtractPartsFromGenBank
if {$I==""} { set I 0 }
if {$J==""} { set J 99999999 }
set LesParts {}
while {[info exists ExtractPartsFromGenBank]} {
if {$ExtractPartsFromGenBank(filename)!=$Fichier || $I=="close" || $ExtractPartsFromGenBank(Vu) >= $I} {
catch { close $ExtractPartsFromGenBank(f) }
unset ExtractPartsFromGenBank
if {$I=="close"} { return }
break
}
set f $ExtractPartsFromGenBank(f)
set Vu $ExtractPartsFromGenBank(Vu)
break
}
if { ! [info exists ExtractPartsFromGenBank]} {
set f [open $Fichier "r"]
set ExtractPartsFromGenBank(f) $f
set ExtractPartsFromGenBank(filename) $Fichier
set Vu -1
}
set Prends 0
set LeCourant {}
while {[gets $f Ligne]>=0} {
if {[regexp {^LOCUS} $Ligne]} {
incr Vu
if {$J < $Vu} { break }
if {$Vu < $I } { continue }
set Prends 1
lappend LeCourant $Ligne
continue
}
if { ! $Prends } { continue }
lappend LeCourant $Ligne
if {[regexp "^//" $Ligne]} {
lappend LesParts [join $LeCourant "\n"]
set LeCourant {}
if {$J == $Vu} { break }
}
}
set ExtractPartsFromGenBank(Vu) $Vu
return $LesParts
}
proc OldSequenceFormatTFADuEMBLMultiple {TexteOuFichier {NomDeBapteme ""}} {
if {[regexp "\n" $TexteOuFichier]} {
set Texte $TexteOuFichier
} else {
set Texte [ContenuDuFichier $TexteOuFichier]
}
set LesTFA {}
set ISS -1
while {[set Debut [string first {ID } $Texte $ISS]] >= 0} {
set Texte [string range $Texte $Debut end]
set ISS [string first "\n//" $Texte]
if {$ISS<10} { set ISS "end" }
set Premier [string range $Texte 0 $ISS]
lappend LesTFA [SequenceFormatTFA $Premier $NomDeBapteme "embl"]
if {$ISS == "end"} { break }
}
return [join $LesTFA "\n"]
}
proc SequenceFormatTFADuEMBLMultiple {FichierOuTexte {NomDeBapteme ""} {Deb ""} {Fin ""}} {
if {$Deb==""} { set Deb 0 }
if {$Fin==""} { set Fin 9999999 }
set LesTFA {}
for {set I $Deb} {$I<=$Fin} { incr I} {
set LePremier [ExtractPartsFromEMBL $FichierOuTexte $I $I]
if {$LePremier=={}} { break }
set Premier [lindex $LePremier 0]
lappend LesTFA [SequenceFormatTFA $Premier $NomDeBapteme "embl"]
}
ExtractPartsFromEMBL $FichierOuTexte "close"
return [join $LesTFA "\n"]
}
proc SequenceFormatTFADuGenBankMultiple {Fichier {NomDeBapteme ""} {Deb ""} {Fin ""}} {
if {$Deb==""} { set Deb 0 }
if {$Fin==""} { set Fin 9999999 }
set FGB ""
if {[regexp ".gz$" $Fichier]} {
set FGB "[TmpFile].gb"
exec gunzip -c $Fichier > $FGB
set Fichier $FGB
}
set LesTFA {}
for {set I $Deb} {$I<=$Fin} {incr I} {
set LePremier [ExtractPartsFromGenBank $Fichier $I $I]
if {$LePremier=={}} { break }
set Premier [lindex $LePremier 0]
set TFA [SequenceFormatTFA $Premier $NomDeBapteme "gbprot"]
if {$TFA==""} { continue }
lappend LesTFA $TFA
}
ExtractPartsFromGenBank $Fichier "close"
if {$FGB!="" && [file exists $FGB]} { file delete $FGB }
return [join $LesTFA "\n"]
}
proc SequenceFormatTFA_l {LaSequence {NomDeBapteme ""} {Format ""} {WithoutGap ""}} {
return [SequenceFormatTFA [join $LaSequence "\n"] $NomDeBapteme $Format $WithoutGap]
}
proc SequenceFormatTFADuFichier {Fichier {NomDeBapteme ""} {Format ""} {WithoutGap ""}} {
return [SequenceFormatTFA [ContenuDuFichier $Fichier] $NomDeBapteme $Format $WithoutGap]
}
proc SequenceFormatTFA {Sequence {NomDeBapteme ""} {Format ""} {WithoutGapForTFA ""}} {
#rR attention withoutGapNeMarche que pour un tfa
set WithoutGapForTFA [string equal -nocase "WithoutGapForTFA" $WithoutGapForTFA]
Wup "Sequence peut etre une sequence au format Format ou du simple texte"
set NomParDefaut "unamed"
# if {$NomDeBapteme==""} { set NomDeBapteme $NomParDefaut }
regsub {^>} $NomDeBapteme "" NomDeBapteme
if {[set ForceHeader [regexp "^ForceHeaderTo=" $NomDeBapteme]]} {
regsub "^ForceHeaderTo=" $NomDeBapteme "" NomDeBapteme
}
if {$Format==""} { set Format [FormatDeLaSequence $Sequence] }
if {$Format=="tfa" && $NomDeBapteme=="" && ! $WithoutGapForTFA} { return $Sequence }
if {$Format=="tfa"} {
set Seq [QueLaSequenceDuTexteTFA $Sequence]
if {$WithoutGapForTFA} { regsub -all -nocase {[^A-Z]} $Seq "" Seq }
return [SequenceFormatTFA $Seq $NomDeBapteme "brut"]
}
if {$Format=="tfas"} { return $Sequence }
if {$Format=="embl" || $Format=="protembl" || $Format=="nucembl" } {
set LesLignesEMBL [split $Sequence "\n"]
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceBrute
#LP set ID "TR:$ID"
#LP set OS "OS:$OS"
if {$ForceHeader} {
if {$NomDeBapteme==""} { set NomDeBapteme $NomParDefaut }
set Entete $NomDeBapteme
} else {
if {$NomDeBapteme=="ID"} { set NomDeBapteme $ID }
if {$NomDeBapteme=="AC"} { set NomDeBapteme $AC }
if {$NomDeBapteme=="OS"} { set NomDeBapteme $OS }
if {[regexp "fields_" $NomDeBapteme]} {
set LesFields {}
foreach F [split $NomDeBapteme "_"] {
if {[info exists $F]} {lappend LesFields [set $F]}
}
set NomDeBapteme [join $LesFields " "]
}
if {$NomDeBapteme=="" || $NomDeBapteme==$NomParDefaut} { set NomDeBapteme "$AC $OS $DE ($ID)" }
set Entete [string range "$NomDeBapteme" 0 998]
regsub "$AC $AC " $Entete "$AC " Entete
}
regsub -all {>} $Entete " " Entete
set Entete [string trim $Entete]
set TFA ">$Entete\n[SequenceFormatBrut $SequenceBrute]"
return $TFA
}
if {$Format=="gbprot" || $Format=="genbank" } {
LesKeywordsInteressantsDuGenbank $Sequence Tab LOCUS ACCESSION DEFINITION SOURCE ORIGIN
set Seq [StringSuivant "ORIGIN" dans $Tab(ORIGIN)]
set ID [StringApres "LOCUS" dans $Tab(LOCUS)]
set AC [StringApres "ACCESSION" dans $Tab(ACCESSION)]
set DE [StringSuivant "DEFINITION" dans $Tab(DEFINITION)]
regsub -all {[ \n]+} $DE " " DE
set Source [StringSuivant "SOURCE" dans $Tab(SOURCE)]
set LaSource [split $Source "\n"]
set Vulgaire ""
if {[regexp {\(([^\)]+)\)} [lindex $LaSource 0] Match Vul]} { set Vulgaire $Vul }
set OS [StringSuivant "ORGANISM" dans [lindex $LaSource 1]]
if {$OS==""} {set OS [StringSuivant "ORGANISM" dans [lindex $LaSource 2]]}
set OS [string trim $OS]
set OC [join [lrange $LaSource 2 end] " "]
regsub -all {[ \n]+} $OC " " OC
set AvecFields 0
if {$ForceHeader} {
if {$NomDeBapteme==""} { set NomDeBapteme $NomParDefaut }
set Entete $NomDeBapteme
} else {
if {$NomDeBapteme=="ID"} { set NomDeBapteme $ID }
if {$NomDeBapteme=="AC"} { set NomDeBapteme $AC }
if {$NomDeBapteme=="OS"} { set NomDeBapteme $OS }
if {[regexp "fields_" $NomDeBapteme]} {
set AvecFields 1
set LesFields {}
foreach F [split $NomDeBapteme "_"] {
if {[regexp {^([A-Z]+)with(.+)$} $F Match Field Filter]} {
if { ! [info exists $Field] } { return "" }
if { ! [regexp -nocase $Filter [set $Field]] } { return "" }
continue
}
if {[info exists $F]} { lappend LesFields [set $F] }
}
set NomDeBapteme [join $LesFields " "]
}
if {$NomDeBapteme=="" || $NomDeBapteme==$NomParDefaut} { set NomDeBapteme "$AC $OS $DE ($ID)"}
set Entete [string range "$NomDeBapteme" 0 998]
if { ! $AvecFields} { regsub "$AC $AC " $Entete "$AC " Entete }
}
regsub -all {>} $Entete " " Entete
set Entete [string trim $Entete]
set TFA ">$Entete\n[SequenceFormatBrut $Seq]"
return $TFA
}
if {$Format=="gcg" || $Format=="gcgmaybe"} {
set LesLignesGCG [split $Sequence "\n"]
set iAC [lsearch -regexp $LesLignesGCG "^AC "]
if {$iAC>0} {
scan [lindex $LesLignesGCG $iAC] "%s %s" Cle Access
regsub -all {[^a-zA-Z0-9_]} $Access "" Access
} elseif { [set iACCESSION [lsearch -regexp $LesLignesGCG "^ACCESSION "]] > -1 } {
scan [lindex $LesLignesGCG $iACCESSION] "%s %s" Cle Access
regsub -all {[^a-zA-Z0-9_]} $Access "" Access
} else {
set Access ""
}
set DE ""
set iDE [lsearch -regexp $LesLignesGCG "^DE "]
if {$iDE>0} {
set DE [string range [lindex $LesLignesGCG $iDE] 5 end]
} elseif { [set iDEFINITION [lsearch -regexp $LesLignesGCG "^DEFINITION "]] > -1 } {
set DE [string trim [string range [lindex $LesLignesGCG $iDEFINITION] 11 end]]
while {[regexp {^ } [lindex $LesLignesGCG [incr iDEFINITION]]]} {
append DE " [string trim [lindex $LesLignesGCG $iDEFINITION]]"
}
} else {
set DE ""
}
set iPP [lsearch -regexp $LesLignesGCG {\.\.}]
set SequenceBrute [join [lrange $LesLignesGCG [incr iPP] end] ""]
regsub -all {[0-9\n \t]} $SequenceBrute "" SequenceBrute
if {$NomDeBapteme==""} { set NomDeBapteme $NomParDefaut }
if {$NomDeBapteme==$NomParDefaut) && $Access!=""} { set NomDeBapteme $Access }
set Entete [string range "$NomDeBapteme $Access $DE" 0 998]
regsub -all {>} $Entete " " Entete
set Entete [string trim $Entete]
set TFA ">$Entete\n[SequenceFormatBrut $SequenceBrute]"
return $TFA
}
if {$Format=="brut" || $Format=="protbrut" || $Format=="nucbrut"} {
if {$NomDeBapteme==""} { set NomDeBapteme $NomParDefaut }
set Entete $NomDeBapteme
regsub -all {>} $Entete " " Entete
set Entete [string trim $Entete]
set TFA ">$Entete\n[SequenceFormatBrut $Sequence]"
return $TFA
}
FaireLire "Unknown sequence format. I don't convert to TFA."
return ""
}
proc PrepareLesSequencesDesBanques {lBanqueId {lAccess ""} {BanqueBlast ""}} {
#rR autrefois on utilisait QuidSeq maintenant c'est GeneQuid
#rR Maintenant on utilise de preference le premier lBanqueId pour GeneQuid
#rR Le lAccess sert pour stocker le résultat car on cree un table
#rR LesLignesEMBLEnMemoire($BanqeId,$Access)
#rR set lAccess est vide il est rempli avec lBanqueId
global LesLignesEMBLEnMemoire
global AccessOKEnMemoire
if {$lBanqueId=="YaQuelqun"} {
return [info exists LesLignesEMBLEnMemoire]
}
if {[info exists LesLignesEMBLEnMemoire]} { unset LesLignesEMBLEnMemoire }
if {[info exists AccessOKEnMemoire]} { unset AccessOKEnMemoire }
if { ! [regexp -nocase {[a-z]} $lBanqueId]} { return 0 }
if {$lAccess=={}} { set lAccess $lBanqueId }
set LesBonsBanqueId {}
foreach BanqueId $lBanqueId Access $lAccess {
if {[EstUnAccessPDB $BanqueId]} { continue }
lappend LesBonsBanqueId $BanqueId
set BAs([string toupper $BanqueId]) "$BanqueId,$Access"
}
if {$LesBonsBanqueId=={}} { return 0 }
set Queries [join $lBanqueId ","]
set Retour [GeneQuid UniprotData $Queries "+QY"]
set NbTrouves 0
foreach Ligne [split $Retour "\n"] {
if {[regexp {^QY (.+)} $Ligne Match Query]} {
set LEmblDuQuery {}
continue
}
lappend LEmblDuQuery $Ligne
if {[regexp {^//} $Ligne]} {
set QUERY [string toupper $Query]
if { ! [info exists BAs($QUERY)]} { continue }
#rR rajouté 20171031 car on avait juste // pour les non trouvés.
#rR De plus j'ai rajoute qu'on cherche dans la banque blast si ele est founie.
if {[llength $LEmblDuQuery]<3} {
if {$BanqueBlast==""} { continue }
if {$BanqueBlast=="DefaultBlastPDatabase"} {
set BD [LocaliseBlastPDataBase]
Espionne "BD $BD"
if {$BD==""} { continue }
set TFA [TFADeLaBanqueBlast $BD $Query]
if {$TFA==""} { continue}
regsub {>lcl\|} $TFA ">" TFA
set EMBL [SequenceFormatEMBL $TFA "" "tfa"]
set LEmblDuQuery [split $EMBL "\n"] ;#rR c'est bon on le tient !!!
}
}
set LesLignesEMBLEnMemoire($BAs($QUERY)) $LEmblDuQuery
set AccessOKEnMemoire($BAs($QUERY)) $Query
incr NbTrouves
continue
}
}
return $NbTrouves
#rR on utilisait QuidSeq ... qui est, maintenant, obsolète ...
if { ! [QuidSeqEstDisponible]} { return "" }
if {[info exists LesLignesEMBLEnMemoire]} { unset LesLignesEMBLEnMemoire }
if {[info exists AccessOKEnMemoire]} { unset AccessOKEnMemoire }
if { ! [regexp -nocase {[a-z]} $lBanqueId]} { return 0 }
if {$lAccess=={}} { set lAccess $lBanqueId }
if { ! [info exists QuidSeqEstDisponible] || ! $QuidSeqEstDisponible } { return }
set LesBonsAccess {}
foreach BanqueId $lBanqueId Access $lAccess {
if {[EstUnAccessPDB $BanqueId]} { continue }
lappend LesBonsAccess $Access
set BAs([string toupper $Access]) "$BanqueId,$Access"
}
if {$LesBonsAccess=={}} { return 0 }
set AccessJoints [join $LesBonsAccess "|"]
Wup "This magical programming works : QuidAllRefsSeqsOfACs sends the array SequencesFromQuidSeq"
set Reponse [QuestionDeScience QuidSeq "QuidAllRefsSeqsOfACs $AccessJoints"]
regsub "Array: " $Reponse "" Reponse
if { ! [regexp -nocase {[a-z]} $Reponse]} { return 0 }
eval array set $Reponse
set n 0
foreach {AC Embl} [array get SequencesFromQuidSeq] {
if {$Embl=="" || $Embl=="NotFound"} { continue }
set LesLignesEMBL [split $Embl "\n"]
set BA [set BAs([string toupper $AC])]
set LesLignesEMBLEnMemoire($BA) $LesLignesEMBL
set AccessOKEnMemoire($BA) $AC
incr n
}
return $n
}
proc SembleEtreUnAccessVarsplic Access {
if {[regexp -nocase {[A-Z][0-9]+\-[0-9]{1,2}$} $Access]} { return 1 }
return 0
}
proc SequenceDesBanquesVite {Access {OnVeutEMBL ""}} {
return [join [LaSequenceDesBanques $Access $Access AccessOK $OnVeutEMBL] "\n"]
}
proc SequenceDesBanques args {
return [join [eval LaSequenceDesBanques $args] "\n"]
}
proc PremierEMBL Texte {
Espionne [string length $Texte]
regsub {\n//\n.*} $Texte "\n//" Texte
Espionne [string length $Texte]
return $Texte
}
proc EstUnGI {Access} {
return [string is integer -strict $Access]
}
proc EstUnUniProt {Access} {
#lM y a mieux mais c'est plus cher
if {[EstUnAccUniProt $Access]} { return 1 }
if {[EstUnIdUniprot $Access]} { return 1 }
if {[EstUnIdSwissProt $Access]} { return 1 }
return 0
}
proc EstUnIdSwissProt {Access} {
#rR il n'y a que 5 caracteres pour l'Id
if {[regexp -nocase {^[A-Z0-9]{1,5}_[A-Z0-9]{1,5}$} $Access]} { return 1 }
return 0
}
proc EstUnIdUniprot {Access} {
#rR il y a jusqu'à 6 caracteres pour l'Id (c'est souvent le Acc)
if {[regexp -nocase {^[A-Z0-9]{1,6}_[A-Z0-9]{1,5}$} $Access]} { return 1 }
return 0
}
proc EstUnAccUniProt {Access} {
#lm taken from :
#lm http://www.uniprot.org/manual/accession_numbers
#rR il peut y avoir un numero de version optionnel .3 ou .12 a la fin
#
#lm ajoute nouveau format d accession number sur 10 chars
#lm pris de http://www.uniprot.org/help/accession_numbers
if {[regexp -nocase {^[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9]([A-Z][A-Z0-9]{2}[0-9]){1,2}(\.[0-9]+)?$} $Access]} {
return 1
} else {
return 0
}
#lm ancien :
if {[regexp -nocase {^([A-NR-Z][0-9][A-Z][A-Z0-9][A-Z0-9][0-9]|[OPQ][0-9][A-Z0-9][A-Z0-9][A-Z0-9][0-9])(\.[0-9]+)?$} $Access]} {
return 1
} else {
return 0
}
}
proc EstUnRefseq Access {
return [regexp -nocase {^(REFSEQ.?\:)?(AC|AP|NC|NG|NM|NM|NP|NP|NR|NT|NW|NW|XM|XM|XP|XP|XR|YP|YP|ZP|NS)_[0-9]{6,9}(\.[0-9]+)?$} $Access]
}
proc TestLaSequenceDesBanques {BanqueId {Access ""} {aAccessOK ""} {OnVeutEMBL ""} {NouveauPABCourant ""}} {
set LaSeq [LaSequenceDesBanques $BanqueId $Access AccessOK $OnVeutEMBL $NouveauPABCourant]
set R [concat $LaSeq [list "\n" $AccessOK]]
return $R
}
proc LaSequenceDesBanques {BanqueId {Access ""} {aAccessOK ""} {OnVeutEMBL ""} {NouveauPABCourant ""}} {
LogWscope "dans LaSequenceDesBanques $BanqueId"
if {$OnVeutEMBL=="" && [regexp "^OnVeut" $Access]} {
set OnVeutEMBL $Access
set Access ""
}
if {$aAccessOK!=""} { upvar $aAccessOK AccessOK }
global RepertoireDuGenome
global LesLignesEMBLEnMemoire
global AccessOKEnMemoire
global ConfigChargee
global QuidSeqEstDisponible
global PABCourant
global EviteSPTNEW
set BanqueIdOriginal $BanqueId
if {[regexp "\|" $BanqueId]} {
regsub -nocase {^(sp|sw|lcl)\|} $BanqueId "" BanqueId
}
if {[regexp "\|" $BanqueId]} {
lassign [split $BanqueId "|"] B A
set BanqueId $B
if {$Access=="" || $Access==$BanqueIdOriginal} { set Access $A }
}
if {[regexp {^(Joy[A-Z][a-z]CDS)[0-9]+$} $BanqueId Match Science]} {
#rR Specifique aux projets JoyScCDS, JoyDhCDS, etc.
set RepProt "[GscopeDatabaseDir $Science]/prottfa"
if {[regexp -nocase "Nature" $OnVeutEMBL]} { set RepProt "[GscopeDatabaseDir $Science]/nuctfa" }
set FichierTFA "$RepProt/$Match"
if {[file exists $FichierTFA]} {
set AccessOK $Match
return [LesLignesDuFichier $FichierTFA]
}
}
if {[regexp "Sc306" [RepertoireDuGenome]]} {
if {[regexp {^(Sc|Eh|At|Hs)[0-9]+$} $BanqueId Match]} {
set RepProt "[GscopeDatabaseDir YEAH]/prottfa"
set FichierTFA "$RepProt/$Match"
if {[file exists $FichierTFA]} {
set AccessOK $Match
return [LesLignesDuFichier $FichierTFA]
}
}
if {[regexp {^(PF)[^ ]*} $BanqueId Match]} {
set RepProt "[GscopeDatabaseDir Pfalciparum]/prottfa"
set FichierTFA "$RepProt/$Match"
if {[file exists $FichierTFA]} {
set AccessOK $Match
return [LesLignesDuFichier $FichierTFA]
}
}
if {[regexp {^(TB)[^ ]*} $BanqueId Match]} {
set RepProt "[GscopeDatabaseDir Tbrucei]/prottfa"
set FichierTFA "$RepProt/$Match"
if {[file exists $FichierTFA]} {
set AccessOK $Match
return [LesLignesDuFichier $FichierTFA]
}
}
}
if {[regexp "YEAH|Tparva" [RepertoireDuGenome]]} {
if {[regexp {^(Sc|Eh|At|Hs)[0-9]+$} $BanqueId Match]} {
set RepProt "[GscopeDatabaseDir YEAH]/prottfa"
set FichierTFA "$RepProt/$Match"
if {[file exists $FichierTFA]} {
set AccessOK $Match
return [LesLignesDuFichier $FichierTFA]
}
}
if {[regexp {^(PF)[^ ]*} $BanqueId Match]} {
set RepProt "[GscopeDatabaseDir Pfalciparum]/prottfa"
set FichierTFA "$RepProt/$Match"
if {[file exists $FichierTFA]} {
set AccessOK $Match
return [LesLignesDuFichier $FichierTFA]
}
}
if {[regexp {^(TB)[^ ]*} $BanqueId Match]} {
set RepProt "[GscopeDatabaseDir Tbrucei]/prottfa"
set FichierTFA "$RepProt/$Match"
if {[file exists $FichierTFA]} {
set AccessOK $Match
return [LesLignesDuFichier $FichierTFA]
}
}
}
if {[regexp {^ref\|([^\|]+)} $BanqueId Match X]} {
regsub {\.[0-9]*} $X "" X
set BanqueId "refseq:$X"
set Access ""
}
if {$BanqueId==""} { set BanqueId $Access}
if {$Access==""} { set Access $BanqueId }
if {$BanqueId=="" && $Access==""} { set AccessOK "" ; return {} }
if {[regexp "^OnVeut" $Access]} {
set OnVeutEMBL $Access
set Access $BanqueId
}
set OnVeutGenBank [string equal -nocase $OnVeutEMBL "OnVeutGenBank"]
set Force 1
set Previens 0
set OnExigeNature 0
if {[string equal -nocase $OnVeutEMBL "OnVeutNature"]} {
set OnExigeNature 1
set OnVeutEMBL ""
}
if {[regexp -nocase "^EST" $BanqueId] && [string equal -nocase $OnVeutEMBL "OnVeutEMBL"]} { set OnVeutEMBL "OnVeutNucEMBL" }
set OnExigeNuc 0
if {[string equal -nocase $OnVeutEMBL "OnVeutNucEMBL"]} {
set OnVeutEMBL "OnVeutEMBL"
set OnExigeNuc 1
}
if {[string equal -nocase $OnVeutEMBL "OnVeutEMBL"]} {
set OnVeutEMBL 1
} else {
set OnVeutEMBL 0
}
while {[regexp {^SCB\:} $BanqueId]} {
set FichierTFAsSCB "/genomics/link/Riboalvi/banques/SCB"
if {[FileAbsent $FichierTFAsSCB]} { break }
set TFA [LaSequenceDuTFAs $FichierTFAsSCB $BanqueId]
set AccessOK $BanqueId
if { ! $OnVeutEMBL} { return [split $TFA "\n"] }
set EMBL [SequenceFormatEMBL $TFA "" "tfa"]
return [split $EMBL "\n"]
}
while {[regexp {^BSDProtAll\:} $BanqueId]} {
set FichierTFAsBSD "/genomics/link/BSD/prottfa/$Access"
if {[FileAbsent $FichierTFAsBSD]} { break }
set TFA [LaSequenceDuTFAs $FichierTFAsBSD $Access]
set AccessOK $BanqueId
if { ! $OnVeutEMBL} { return [split $TFA "\n"] }
set EMBL [SequenceFormatEMBL $TFA "" "tfa"]
return [split $EMBL "\n"]
}
while {[regexp {^(ALVE|ALBO|ALGI)[0-9]+$} $BanqueId]} {
set FichierTFAsAlvinella "/genomics/link/Riboalvi/banques/protAlvinella.tfa"
if {[FileAbsent $FichierTFAsAlvinella]} { break }
set TFA [LaSequenceDuTFAs $FichierTFAsAlvinella $BanqueId]
set AccessOK $BanqueId
if { ! $OnVeutEMBL} { return [split $TFA "\n"] }
set LesOSOCOX {}
lappend LesOSOCOX "OS Alvinella pompejana."
lappend LesOSOCOX "OC Eukaryota; Metazoa; Annelida; Polychaeta; Palpata; Canalipalpata;"
lappend LesOSOCOX "OC Terebellida; Alvinellidae; Alvinella."
lappend LesOSOCOX "OX NCBI_TaxID=6376;"
set OSOCOX [join $LesOSOCOX "\n"]
set EMBL [SequenceFormatEMBL $TFA "" "tfa"]
regsub "\nDE " $EMBL "\n$OSOCOX\nDE Hypothetical protein " EMBL
return [split $EMBL "\n"]
}
#rR On devrait traiter tout REFSEQ avec ceci (y a pas NZ voir lbgiki)
if {0 && [EstUnRefseq $Access]} {
regsub -nocase {^REFSEQ.?\:} $Access "" Acc
set R [BirdWeb "REFSEQ" $Acc]
if {$R!=""} {
set AccessOk $Acc
if {$OnVeutGenBank} { return [split $R "\n"] }
return [split [GenBankToEMBL $R] "\n"]
}
}
#rR sinon on fait comme dans le temps
if {0 && [regexp -nocase {^REFSEQ.*\:} $BanqueId]} {
regsub -nocase {^REFSEQ.*\:} $BanqueId "" A
set R [BirdWeb REFSEQ $A]
if {$R!=""} {
set AccessOk $Acc
if {$OnVeutGenBank} { return [split $R "\n"] }
return [split [GenBankToEMBL $R] "\n"]
}
}
if {0 && [regexp -nocase {^(REFSEQ\:)?(NP|XP)_[0-9]+$} $Access]} {
regsub -nocase {^REFSEQ\:} $Access "" Acc
set R [BirdWeb "REFSEQP" $Acc]
if {$R!=""} {
set AccessOk $Acc
if {$OnVeutGenBank} { return [split $R "\n"] }
return [split [GenBankToEMBL $R] "\n"]
}
set R [Getz $Acc "refseqP" -view FastaSeqs]
if {$R!=""} {
set AccessOk $Acc
if {$OnVeutGenBank} { return [split $R "\n"] }
set iSecondChevron [string first ">" $R 2]
if {$iSecondChevron>-1} { set R [string range $R 0 [incr iSecondChevron -1]] }
set R [SequenceFormatEMBL $R "" "tfa" "No" "No"]
return [split $R "\n"]
}
}
if {0 && [regexp -nocase {^(REFSEQ\:)?(NM|XM)_[0-9]+$} $Access]} {
regsub -nocase {^REFSEQ\:} $Access "" Acc
set R [BirdWeb "REFSEQ" $Acc]
if {$R!=""} {
set AccessOk $Acc
if {$OnVeutGenBank} { return [split $R "\n"]}
return [split [GenBankToEMBL $R] "\n"]
}
set R [Getz $Acc "refseq" -view FastaSeqs]
if {$R!=""} {
set AccessOk $Acc
if {$OnVeutGenBank} { return [split $R "\n"] }
set iSecondChevron [string first ">" $R 2]
if {$iSecondChevron>-1} { set R [string range $R 0 [incr iSecondChevron -1]] }
set R [SequenceFormatEMBL $R "" "tfa" "No" "No"]
return [split $R "\n"]
}
}
if {[regexp -nocase {^HS[0-9unxy]+\:} $BanqueId BanqueHS]} {
regsub {\:} $BanqueHS "" BanqueHS
set BanqueHS [string tolower $BanqueHS]
if {[catch {set TfaDeLaBanqueBlast \
[exec fastacmd -d $BanqueHS -s $BanqueId 2> /dev/null]} Message]} {
return ""
}
if {$OnVeutEMBL} {
return [split [SequenceFormatEMBL $TfaDeLaBanqueBlast "" "tfa"] "\n"]
}
return [split $TfaDeLaBanqueBlast "\n"]
}
if {[regexp -nocase {^UniRef[0-9]+} $BanqueId Match]} {
if {[regexp -nocase {^UniRef[0-9]+_([A-Z][A-Z0-9]+)} $BanqueId M Acc]} {
set AOk $BanqueId
set R [LaSequenceDesBanques "protein:$Acc" $Acc AOkBidon $OnVeutEMBL $NouveauPABCourant]
if {$R!=""} {
set AccessOK $AOk
return $R
}
}
set Banque [string tolower $Match]
if {[catch {set TfaDeLaBanqueBlast [exec fastacmd -d $Banque -s $BanqueId 2> /dev/null]} Message]} {
set AccessOK ""
return ""
}
if {[regexp {^>lcl\|} $TfaDeLaBanqueBlast]} {
regsub {^>lcl\|} $TfaDeLaBanqueBlast ">" TfaDeLaBanqueBlast
}
set AccessOK $BanqueId
if { ! $OnVeutEMBL} { return [split $TfaDeLaBanqueBlast "\n"]}
set SeqDesBanques [SequenceFormatEMBL $TfaDeLaBanqueBlast $Access "tfa"]
return [split $SeqDesBanques "\n"]
}
if {[regexp -nocase {Msmegmatis\:|MsAllProt\:} $BanqueId]} {
set NomMs [StringApres ":" dans $BanqueId]
set FicMs "[GscopeDatabaseDir Ms]/protembl/$NomMs"
if {[file exists $FicMs]} {
set AccessOK $BanqueId
return [LesLignesDuFichier $FicMs]
}
set FicMs "[GscopeDatabaseDir Ms]/prottfa/$NomMs"
if {[file exists $FicMs]} {
set AccessOK $BanqueId
set NomLu [StringApres ":" dans $$BanqueId]
return [SequenceFormatEMBL [ContenuDuFichier $FicMs] $NomLu "tfa"]
}
}
if {[regexp -nocase "VARSPLIC\:" $BanqueId]} {
regsub -nocase "VARSPLIC" $BanqueId "PROT" ProtId
regsub -nocase "VARSPLIC\:" $BanqueId "" AccessOK
if {[regexp {_[0-9]+$} $ProtId]} {
regsub {_[0-9]+$} $ProtId "" ProtId
}
if {[regexp {\-[0-9]+$} $ProtId]} {
regsub {\-[0-9]+$} $ProtId "" ProtId
}
set LesLignesEMBL [LaSequenceDesBanques $ProtId]
if {$LesLignesEMBL==""} { set AccessOK "" ; return "" }
set SeqTFA [TfaDeLaBanqueBlast "/catalog/blast/varsplic" $BanqueId]
if {$SeqTFA==""} {
if {[regexp {_[0-9]+$} $BanqueId]} { regsub "_" $BanqueId "-" BanqueId }
set SeqTFA [TfaDeLaBanqueBlast "/catalog/blast/varsplic" $BanqueId]
if {$SeqTFA==""} { set AccessOK "" ; return "" }
}
set Seq [QueLaSequenceDuTexteTFA $SeqTFA]
regsub "VARSPLIC\:" $BanqueId "" Id
set LeNouveau {}
foreach Ligne $LesLignesEMBL {
if {[regexp "^ID " $Ligne]} {
set Ligne "ID $Id VARSPLIC created by Gscope-varsplic.tcl from $ProtId"
append Ligne "\nAC $Id;"
}
if {[regexp "SQ " $Ligne ]} {
break
}
lappend LeNouveau $Ligne
}
lappend LeNouveau [QueSequenceFormatEMBL $Seq AvecSQ]
set AccessOK $BanqueId
return $LeNouveau
}
regsub -nocase "^RSHUM\:" $BanqueId "RSHUMAN:" BanqueId
if {[regexp "RSHUMAN\:" $BanqueId]} { set Access "" }
if { ! [info exists EviteSPTNEW]} { set EviteSPTNEW 1 }
if {[EstUnAccessPDB $BanqueId] || $Access=="mol:protein"} { set Access $BanqueId }
if { ! [regexp {\:} $BanqueId] && [regexp -nocase {(SPT|SW)[_\|]} $BanqueId]} {
regsub {[_\|]} $BanqueId ":" NewBanqueId
if {$BanqueId==$Access} { set Access $NewBanqueId }
set BanqueId $NewBanqueId
}
if {$BanqueId==$Access && [regexp ":" $Access] && ! [regexp -nocase "RSHUMAN\:" $Access]} {
regsub -nocase {[a-z0-9_]+\:} $Access "" Access
}
if {$NouveauPABCourant!=""} { set PABCourant $NouveauPABCourant }
Wup "Fetch the sequence. In EMBL format if OnVeutEMBL."
Wup "BanqueId or Access ? First I try Access then BanqueId"
Wup "Maybe I stored before in memory ..."
if {[info exists LesLignesEMBLEnMemoire($BanqueId,$Access)]} {
set LesLignesEMBL [set LesLignesEMBLEnMemoire($BanqueId,$Access)]
set AccessOK [set AccessOKEnMemoire($BanqueId,$Access)]
return $LesLignesEMBL
}
if {[regexp {^ci[0-9]{10}$} $Access]} {
return [LesLignesDuFichier "/genomics/link/Ciona/protembl/[CioNarcisse $Access]"]
}
if {[regexp {^(ensembl|gp|pironly|remtrembl|worm)\:[a-zA-Z_0-9]+$} $BanqueId]} {
set TFA [LaSequenceDuTFAs "/genomics/link/petitPDBscope/banques/nrdb_specific.tfa" $BanqueId]
if {$TFA==""} { return {} }
if {$OnVeutEMBL} { return [split [SequenceFormatEMBL $TFA "" "tfa"] "\n"] }
return $TFA
}
set LaSequence {}
Wup "It's a file"
if {[regexp "/" $BanqueId]} {
if {[file exists $BanqueId]} {
if {[file isdirectory $BanqueId]} {
set AccessOK ""
return [lsort [glob -nocomplain "$BanqueId/*"]]
}
set LaSequence [LesLignesDuFichier $BanqueId]
# Warne "fichier $BanqueId"
set AccessOK [file tail $BanqueId]
set NomDuFichier [file tail $BanqueId]
set GCG [join $LaSequence "\n"]
if {[regexp "^LOCUS" $GCG]} {
if { ! [regexp {[^\n]* [0-9]+ aa } $GCG]} {
set AccessOK $Access
if {$OnExigeNature} { return [split $GCG "\n"] }
set FichierGB "[RepertoireDeTravail]/$NomDuFichier.gbtags"
Sauve $GCG dans $FichierGB
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] "\n"]
File delete -force $FichierGB
return $LesLignesEMBL
} else {
set AccessOK $Access
if {$OnExigeNature} { return [split $GCG "\n"] }
set FichierGB "[RepertoireDeTravail]/$NomDuFichier.gbk"
Sauve $GCG dans $FichierGB
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqProt $FichierGB] "prot"] "\n"]
File delete -force $FichierGB
return $LesLignesEMBL
}
}
return [LaSequenceConvertieSiOnVeut $LaSequence $OnVeutEMBL $NomDuFichier]
}
if { $Previens } { FaireLire "$BanqueId not found in databases." }
return {}
}
if {[OnTraiteUneCollection] && [info exists PABCourant]} {
set Copain "$RepertoireDuGenome/coembl/$PABCourant/$Access"
if {[file exists $Copain]} {
set AccessOK $Access
set LesLignesEMBL [LesLignesDuFichier $Copain]
return $LesLignesEMBL
}
if {[file exists "$RepertoireDuGenome/genscanpredictions/$PABCourant"]} {
set Texte [ContenuDuFichier "$RepertoireDuGenome/genscanpredictions/$PABCourant"]
if {[regexp "^>$Access " $Texte]} {
return [split [SequenceFormatEMBL $Texte "" "tfa"] "\n"]
}
}
}
foreach SousRep {"Spine/Sequences"} {
if {[file exists "$RepertoireDuGenome/$SousRep/$Access"]} {
set AccessOK $Access
set Texte [ContenuDuFichier "$RepertoireDuGenome/$SousRep/$Access"]
set LesLignesEMBL [split [SequenceFormatEMBL $Texte] "\n"]
return $LesLignesEMBL
}
}
if {[EstUnPAB $BanqueId]} {
if {[file exists "$RepertoireDuGenome/protembl/$BanqueId"]} {
set AccessOK $BanqueId
set LesLignesEMBL [LesLignesDuFichier "$RepertoireDuGenome/protembl/$BanqueId"]
return $LesLignesEMBL
}
if {[file exists "$RepertoireDuGenome/nucembl/$BanqueId"]} {
set AccessOK $BanqueId
set LesLignesEMBL [LesLignesDuFichier "$RepertoireDuGenome/nucembl/$BanqueId"]
return $LesLignesEMBL
}
}
if {[EstUnPAB $Access]} {
if {[file exists "$RepertoireDuGenome/protembl/$Access"]} {
set AccessOK $Access
set LesLignesEMBL [LesLignesDuFichier "$RepertoireDuGenome/protembl/$Access"]
return $LesLignesEMBL
}
if {[file exists "$RepertoireDuGenome/nucembl/$Access"]} {
set AccessOK $Access
set LesLignesEMBL [LesLignesDuFichier "$RepertoireDuGenome/nucembl/$Access"]
return $LesLignesEMBL
}
}
if {[EstUnPAB $BanqueId]} {
if {[file exists "$RepertoireDuGenome/prottfa/$BanqueId"]} {
set AccessOK $BanqueId
set LesLignesEMBL [split [SequenceFormatEMBLDuFichierTFA "$RepertoireDuGenome/prottfa/$BanqueId"] "\n"]
return $LesLignesEMBL
}
if {[file exists "$RepertoireDuGenome/nuctfa/$BanqueId"]} {
set AccessOK $BanqueId
set LesLignesEMBL [split [SequenceFormatEMBLDuFichierTFA "$RepertoireDuGenome/nuctfa/$BanqueId"] "\n"]
return $LesLignesEMBL
}
}
if {[EstUnPAB $Access]} {
if {[file exists "$RepertoireDuGenome/prottfa/$Access"]} {
set AccessOK $Access
set LesLignesEMBL [split [SequenceFormatEMBLDuFichierTFA "$RepertoireDuGenome/prottfa/$Access"] "\n"]
return $LesLignesEMBL
}
if {[file exists "$RepertoireDuGenome/nuctfa/$Access"]} {
set AccessOK $Access
set LesLignesEMBL [split [SequenceFormatEMBLDuFichierTFA "$RepertoireDuGenome/nuctfa/$Access"] "\n"]
return $LesLignesEMBL
}
}
Wup "I search in seqpath"
if {[file exists "$RepertoireDuGenome/seqpath"]} {
foreach Ext {".pep" ".embl" ".tfa" ""} {
set Liste [glob -nocomplain "$RepertoireDuGenome/seqpath/*/$Access$Ext"]
foreach Fichier $Liste {
set LaSequence [LesLignesDuFichier $Fichier]
if {[llength $LaSequence] == 0} { continue }
set AccessOK $Access
return [LaSequenceConvertieSiOnVeut $LaSequence $OnVeutEMBL $Access]
}
}
}
if {[regexp "^EVImmProt\:" $BanqueId]} {
set NomDuEVI [lindex [split $BanqueId ":"] 1]
set FichierEVI "[GscopeDatabaseDir EVImm]/protembl/$NomDuEVI"
if { ! [file exists $FichierEVI]} {
if {$Force} { return {} }
FaireLire "$FichierEVI not found."
return {}
}
set LesLignesEMBL [LesLignesDuFichier $FichierEVI]
set AccessOK $NomDuEVI
return $LesLignesEMBL
}
if {[regexp "^AffyHS\:" $BanqueId]} {
set NomDuAffy [lindex [split $BanqueId ":"] 1]
set FichierAffy "/genomics/link/AffyHS/nucembl/$NomDuAffy"
if { ! [file exists $FichierAffy]} {
if {$Force} { return {} }
FaireLire "$FichierAffy not found."
return {}
}
set LesLignesEMBL [LesLignesDuFichier $FichierAffy]
set AccessOK $NomDuAffy
return $LesLignesEMBL
}
if {0 && [regexp "^PABY\:" $BanqueId]} {
set NomDuPABY [lindex [split $BanqueId ":"] 1]
set FichierPABY "[GscopeDatabaseDir Pabyssi]/protembl/$NomDuPABY"
if { ! [file exists $FichierPABY]} {
if {$Force} { return {} }
FaireLire "$FichierPABY not found."
return {}
}
set LesLignesEMBL [LesLignesDuFichier $FichierPABY]
set AccessOK $NomDuPABY
return $LesLignesEMBL
}
if {[regexp -nocase "^ClonV:" $BanqueId]} {
set NomDuVec [lindex [split $BanqueId ":"] 1]
set FichierVec "$RepertoireDuGenome/vecteurs/$NomDuVec"
if { ! [file exists $FichierVec]} {
if {$Force} { return {} }
FaireLire "$FichierVec not found"
return {}
}
set LesLignesEMBL [LesLignesDuFichier $FichierVec]
set AccessOK $NomDuVec
return $LesLignesEMBL
}
if {0 && [regexp -nocase "^PFUR:" $BanqueId]} {
set NomDuPFUR [lindex [split $BanqueId ":"] 1]
set FichierPFUR "[GscopeDatabaseDir Pfuriosus]/protembl/$NomDuPFUR"
if { ! [file exists $FichierPFUR]} {
if {$Force} { return {} }
FaireLire "$FichierPFUR not found"
return {}
}
set LesLignesEMBL [LesLignesDuFichier $FichierPFUR]
set AccessOK $NomDuPFUR
return $LesLignesEMBL
}
if {[regexp -nocase {^AFF[0-9]{5}$} $Access]} {
set NomDuAffymetrix $Access
set FichierAffymetrix "[GscopeDatabaseDir AffyHS]/nucembl/$NomDuAffymetrix"
if { ! [file exists $FichierAffymetrix]} {
if {$Force} { return {} }
FaireLire "$FichierAffymetrix not found"
return {}
}
set LesLignesEMBL [LesLignesDuFichier $FichierAffymetrix]
set AccessOK $NomDuAffymetrix
return $LesLignesEMBL
}
if {[EstUnAccessPDB $BanqueId]} {
set AccessOK $BanqueId
if {$OnExigeNature} {
set LeNature [split [TextePDB $BanqueId] "\n"] ; #rR attention il faudrait mettre All pour avoir aussi les COORD
return $LeNature
}
set LesLignesEMBL [split [EMBLduPDB $BanqueId] "\n"]
return $LesLignesEMBL
}
if {[QuidSeqEstDisponible]} {
set EMBL [QuestionDeScience QuidSeq "QuidRefSeqOfAC $Access"]
if {[regexp "^ID " $EMBL]} {
set LesLignesEMBL [split $EMBL "\n"]
set AccessOK $Access
# Warne "QuidSeq $Access"
return $LesLignesEMBL
}
}
if {[OutsideCSTB]} {
set LaReponse [WgetzSurWeb $BanqueId]
if {$LaReponse!={} && ! [regexp -nocase "^ERREUR" $LaReponse]} { return $LaReponse }
if {[SembleEtreUnAccessVarsplic $BanqueId]} {
return [LaSequenceDesBanques "VARSPLIC:$BanqueId"]
}
return {}
}
LogWscope "Avant GeneQuid UniprotData $Access"
#rR GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid
set EMBL [GeneQuid UniprotData $Access]
if {[regexp "^ID " $EMBL]} {
set LesLignesEMBL [split $EMBL "\n"]
set AccessOK $Access
# Warne "GeneQuid UniprotData $Access"
return $LesLignesEMBL
}
set EMBL [GeneQuid UniprotData $BanqueId]
if {[regexp "^ID " $EMBL]} {
set LesLignesEMBL [split $EMBL "\n"]
set AccessOK $BanqueId
# Warne "GeneQuid UniprotData $BanqueId"
return $LesLignesEMBL
}
#rR GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid GeneQuid
#rR rajouté le 2014/07/09
if {[UseBirdForUniprot]} {
#Espionne "I use UseBirdForUniprot to search $Access"
if {[regexp {\|} $Access]} {
foreach Mot [split $Access "|"] {
set EMBL [BirdWeb "uniprot" $Mot]
if {[regexp "^ID " $EMBL]} {
set LesLignesEMBL [split $EMBL "\n"]
set AccessOK $Access
Espionne "Bird uniprot $Access"
return $LesLignesEMBL
}
}
}
set EMBL [BirdWeb "uniprot" $Access]
if {[regexp "^ID " $EMBL]} {
set LesLignesEMBL [split $EMBL "\n"]
set AccessOK $Access
Espionne "I got the info using BirdWeb uniprot $Access"
return $LesLignesEMBL
}
} else {
#rR on prendra FromOrthoInspector ou FromYannis voir ci-dessous
}
set EMBL [Getz $Access]
if {[regexp "^ID " $EMBL]} {
set LesLignesEMBL [split $EMBL "\n"]
set AccessOK $Access
Warne "getz $Access"
return $LesLignesEMBL
}
set EMBL [Getz $BanqueId]
if {[regexp "^ID " $EMBL]} {
set LesLignesEMBL [split $EMBL "\n"]
set AccessOK $Access
# Warne "getz $Access"
return $LesLignesEMBL
}
if {[set Alternatif [AccessAlternatif $Access]]!=""} {
set EMBL [Getz $Alternatif]
if {[regexp "^ID " $EMBL]} {
set LesLignesEMBL [split $EMBL "\n"]
set AccessOK $Access
# Warne "getz $Access alternatif $Alternatif"
return $LesLignesEMBL
}
}
if {[SembleEtreUnAccessVarsplic $BanqueId]} {
set LesLignesEMBL [LaSequenceDesBanques "VARSPLIC:$BanqueId"]
if {$LesLignesEMBL!={}} { return $LesLignesEMBL }
}
set GB ""
if {0 && $GB==""} { set GB [BirdWeb "gbrl" $Access] }
if {0 && $GB==""} { set GB [Getz $Access "GenbankFull"] }
if {$GB!="" && [regexp "\nACCESSION" $GB]} {
set AccessOK $Access
if {$OnExigeNature} { return [split $GB "\n"] }
set FichierGB "[RepertoireDeTravail]/$Access.genbank"
Sauve $GB dans $FichierGB
if {$OnExigeNuc} {
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] "\n"]
} else {
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqADN $FichierGB]] "\n"]
}
# File delete -force $FichierGB
return $LesLignesEMBL
}
if {0 && $GB==""} { set GB [Getz $Access "est sts gss htg htc"] }
if {$GB!="" && [regexp "\nACCESSION " $GB]} {
set OnExigeNuc 1
set AccessOK $Access
if {$OnExigeNature} { return [split $GB "\n"] }
set FichierGB "[RepertoireDeTravail]/$Access.gbtags"
Sauve $GB dans $FichierGB
if {$OnExigeNuc} {
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] "\n"]
} else {
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqADN $FichierGB]] "\n"]
}
File delete -force $FichierGB
return $LesLignesEMBL
}
if {[info exists EviteSPTNEW] && $EviteSPTNEW && [regexp -nocase "^SPTNEW" $BanqueId]} {
Warne "$BanqueId $Access not found. I don't search in SPTNEW with GCG"
if { 0 && $Previens } { FaireLire "$BanqueId $Access not found.\
I don't search in SPTNEW with GCG. I ignore it." }
return {}
}
Wup "On ne l'a donc jamais vu ... On essaye GCG."
global TryGCG
if { ! [info exists TryGCG]} {
set TryGCG 0
}
if {$OnExigeNature || $TryGCG} {
set AccessGCG $BanqueId
set GCG [FetchCat $AccessGCG]
if {$GCG == ""} {
set AccessGCG $Access
set GCG [FetchCat $AccessGCG]
}
if {$GCG != ""} {
set GCG [QueLePremierGCG $GCG]
if {[regexp "^!!NA_SEQUENCE" $GCG] && [regexp "\nACCESSION " $GCG]} {
set AccessOK $Access
if {$OnExigeNature} { return [split $GCG "\n"] }
set FichierGB "[RepertoireDeTravail]/$Access.gbtags"
Sauve $GCG dans $FichierGB
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGBTags OS OC SeqADN $FichierGB] "nuc"] "\n"]
File delete -force $FichierGB
return $LesLignesEMBL
}
if {[regexp "^!!AA_SEQUENCE" $GCG] && [regexp "\nACCESSION " $GCG]} {
set AccessOK $Access
if {$OnExigeNature} { return [split $GCG "\n"] }
set FichierGB "[RepertoireDeTravail]/$Access.gbk"
Sauve $GCG dans $FichierGB
set LesLignesEMBL [split [FromInfoOfGenBankToEMBL [DecortiqueGenBank OS OC SeqProt $FichierGB] "prot"] "\n"]
File delete -force $FichierGB
return $LesLignesEMBL
}
set AccessOK $AccessGCG
set LesLignesGCG [split $GCG "\n"]
if { $OnExigeNature} { return $LesLignesGCG }
if { ! $OnVeutEMBL } { return $LesLignesGCG }
set iSQ [lsearch -regexp $LesLignesGCG "^SQ"]
set Entete [lrange $LesLignesGCG 0 $iSQ]
set Suite [lrange $LesLignesGCG $iSQ end]
set iPP [lsearch -regexp $Suite {\.\.}]
set iFin [lsearch -regexp $Suite "^ID"]
if {[incr iFin -1] < 0} { set iFin "end" }
set Sequence [join [lrange $Suite [incr iPP] $iFin] ""]
regsub -all {[ 0-9]} $Sequence "" Sequence
set LaSeqEMBL [split [QueSequenceFormatEMBL $Sequence "SansSQ"] "\n"]
set LesLignesEMBL [concat $Entete $LaSeqEMBL "\n//"]
return $LesLignesEMBL
}
}
if {[OnTraite "CilioCarta"]} {
set TFA [QuestionDeScience EVImm "ret FromYannis $BanqueId TFA"]
if {$TFA!=""} {
set AccessOK $BanqueId
if {$OnVeutEMBL} { return [split [SequenceFormatEMBL $TFA $Access tfa] "\n"] }
return [split $TFA "\n"]
}
}
Warne "$BanqueId $Access not found."
if { $Previens } { FaireLire "$BanqueId introuvable. Je l'ignore." }
return {}
}
proc SequencesDesBanques {Liste {AvecQY ""}} {
set AvecQY [regexp -nocase "QY" $AvecQY]
regsub -all {[ \,\n\;\t]+} $Liste " " Liste
set Liste [string trim $Liste]
set LesAccess [split $Liste " "]
PrepareLesSequencesDesBanques $LesAccess
set LeResultat {}
foreach Access $LesAccess {
set R [SequenceDesBanques $Access]
set R [string trim $R "\n"]
if {$AvecQY} { lappend LeResultat "QY $Access" }
if {$R!=""} { lappend LeResultat $R }
if { ! [regexp {//$} $R] } { lappend LeResultat "//" }
}
return [join $LeResultat "\n"]
}
proc UseBirdForUniprot {{Value ""}} {
#rR c'est pour que DbClustal puisse utiliser FromOrthoInspector ou FromYannis
global UseBirdForUniprot
if {$Value!=""} { set UseBirdForUniprot $Value }
if { ! [info exists UseBirdForUniprot]} { return 0 }
return $UseBirdForUniprot
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.