Index by: file name |
procedure name |
procedure call |
annotation
gscope_collection.tcl
(annotations | original source)
#rR gscope_collection.tcl
proc IsProt {Sequence {ForceNucProt ""}} {
if {$ForceNucProt!=""} {
set IsProt [regexp -nocase "P" $ForceNucProt]
} else {
set Nucs [join [PossibleNucleotides] ""]
set RX "\[^$Nucs\]"
set IsProt [regexp $RX $Sequence]
}
return $IsProt
}
proc IsNuc {Sequence {ForceNucProt ""}} {
if {$ForceNucProt!=""} { return ! [regexp -nocase "P" $ForceNucProt] }
return ! [IsProt $Sequence]
}
proc LesPlusProchesPABs {Sequence {BestOnlyOrExpectOrMaxList ""} {ForceNucProt ""} {BanqueBlast ""} {Programme ""}} {
set SequencePropre ""
foreach Ligne [split $Sequence "\n"] {
if {[regexp ">" $Ligne]} { continue }
regsub -nocase -all {[^a-z]} $Ligne "" S
append SequencePropre $S
}
set Sequence $SequencePropre
set IsProt [IsProt $Sequence $ForceNucProt]
set BanqueProt "[RepertoireDuGenome]/banques/AllProttfa"
set BanqueNuc "[RepertoireDuGenome]/banques/AllNuctfa"
if {$BanqueBlast==""} {
if {$IsProt} {
if {$Programme==""} { set Programme "P" }
set BanqueBlast $BanqueProt
} else {
if {$Programme==""} { set Programme "N" }
set BanqueBlast $BanqueNuc
}
}
set PremiereFois 1
while {[FileAbsent $BanqueBlast]} {
FaireLire "I can not find the BlastDatabase $BanqueBlast\nPlease help me"
set BanqueBlast [Entre $BanqueBlast]
if {[FileExists $BanqueBlast]} { break }
if {$PremiereFois && [OuiOuNon "Do I try tblastN or blastX"]} {
set PremiereFois 0
if {$IsProt} {
if {[file exists $BanqueNuc]} { set Programme "tblastn" ; set BanqueBlast $BanqueNuc ; break}
} else {
if {[file exists $BanqueProt]} { set Programme "blastx" ; set BanqueBlast $BanqueProt ; break}
}
}
if {[OuiOuNon "Do we continue later"]} { return "" }
}
set BlastOut [Blast $Programme $Sequence "retourne" $BanqueBlast "NoGenericCommand"]
if {[regexp -nocase "Best" $BestOnlyOrExpectOrMaxList]} {
set CutPN 0.001
set MaxListe 1
} elseif {[regexp {^[0-9]+$} $BestOnlyOrExpectOrMaxList]} {
set CutPN 0.001
set MaxListe $BestOnlyOrExpectOrMaxList
} elseif {[regexp {^[\.\-\+-eE0-9]+$} $BestOnlyOrExpectOrMaxList]} {
set CutPN $BestOnlyOrExpectOrMaxList
set MaxListe ""
} else {
set CutPN ""
set MaxListe ""
}
set N [DecortiqueBlast $BlastOut $CutPN $MaxListe Query lBanqueId lAccess lDE lProfil lPN]
if {$N==0} { return "" }
set Retour {}
foreach ID $lBanqueId AC $lAccess DE $lDE PN $lPN {
lappend Retour "$ID\t$AC\t$DE\tExpect=$PN"
}
return [join $Retour "\n"]
}
proc Blast {{Programme ""} {Sequence ""} {NomOuNumOuSortie ""} {Banque ""} {WithGenericCommand ""}} {
global RepertoireDuGenome
global Commandes
global BlastCommandeGenerique
Wup "Il existe aussi Blaste plus oriente batch"
if {$WithGenericCommand==""} { set WithGenericCommand "WithGenericCommand" }
set WithGenericCommand [regexp -nocase "^With" $WithGenericCommand]
while {$Sequence==""} {
set Fichier [ButineArborescence "All" "./"]
if {[FileAbsent $Fichier]} {
if {[OuiOuNon "Do I cancel Blast ?"]} { return "" }
continue
}
set Sequence [ContenuDuFichier $Fichier]
Espionne [FormatDeLaSequence $Sequence]
}
if {[regexp "/" $NomOuNumOuSortie]} {
set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
set Sortie $NomOuNumOuSortie
} else {
set Sortie ""
if { $NomOuNumOuSortie == "" } {
set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
} elseif { $NomOuNumOuSortie=="retourne" } {
set NomNum [TmpFile]
set Sortie "retourne"
} elseif { [regexp {^[a-zA-Z]} $NomOuNumOuSortie ] } {
set NomNum ${NomOuNumOuSortie}[NomDe ""]
} elseif { [regexp {^[0-9]} $NomOuNumOuSortie ] } {
set NomNum "[RepertoireDeTravail]/tmp.$NomOuNumOuSortie"
} else {
set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
set Sortie $NomOuNumOuSortie
}
}
set Tmp $NomNum
set In "$Tmp"
set Out "$In.blastp"
set Log "$Out.log"
Sauve [SequenceFormatTFA $Sequence] dans $In
if {$Sortie==""} { set AskOrNot "" } else { set AskOrNot "DontAsk" }
if { $Programme == "P" || [string equal -nocase $Programme "blastp"] } {
if {$Banque==""} { set Banque "/catalog/blast/protall" }
set Prog "blastp"
} elseif { $Programme == "N" || [string equal -nocase $Programme "blastn"] } {
if {$Banque==""} { set Banque "/catalog/blast/genembl" }
set Prog "blastn"
} elseif { $Programme == "X" || [string equal -nocase $Programme "blastx"] } {
if {$Banque==""} { set Banque "/catalog/blast/protein" }
set Prog "blastx"
} elseif { $Programme == "tN" || [string equal -nocase $Programme "tblastn"] } {
if {$Banque==""} { set Banque "/catalog/blast/genomes" }
set Prog "tblastn"
} elseif { $Programme == "tX" || [string equal -nocase $Programme "tblastx"] } {
if {$Banque==""} { set Banque "/catalog/blast/genomes" }
set Prog "tblastn"
} elseif { $Programme == "Choix" } {
set Prog ""
} else {
set Prog [ChoixParmi [list "blastp" "tblastn" "blastx" "blastn" "tblastx"]]
}
if {$WithGenericCommand} {
if { ! [info exists BlastCommandeGenerique]} {
FaireLire "Please modify the parameters of the blast command.\n\
Don't touch the beginning of the command up to IIIIII OOOOOO\n\
I'll keep these parameters for all blast I'll run in this Gscope sessions"
set BlastCommandeGenerique [ChoisisTonBlast IIIIII OOOOOO $Prog $Banque "Ask"]
} else {
set Commande $BlastCommandeGenerique
}
regsub "IIIIII" $Commande $In Commande
regsub "OOOOOO" $Commande $Out Commande
} else {
set Commande [ChoisisTonBlast $In $Out $Prog $Banque "DontAsk"]
}
if {$Commande==""} { return "" }
if {$Sortie!=""} {
regsub {^.*batchcom.tcl *} $Commande "" Commande
set Etat [eval $Commande]
if { ! [file exists $Out]} { return "" }
if {$Sortie=="retourne"} { return [ContenuDuFichier $Out] }
file copy -force $Out $Sortie
return $Sortie
}
Espionne $Commande
if {[catch {set Canal [open "| $Commande"]} Message]} {
Warne $Message
}
fconfigure $Canal -blocking false -buffering line
fileevent $Canal readable "ClosCanalEtMontreBlaste $Canal $Out"
Warne "Blast $Prog lance en batch"
}
proc Blaste {Programme Sequence {NomOuNumOuSortie ""} {Banque ""}} {
global RepertoireDuGenome
global Commandes
Wup "Il existe aussi Blast plus interactif"
if {[FormatDeLaSequence $Sequence] == "tfas"} {
foreach Seq [split [string range $Sequence 1 end] ">"] {
Blaste $Programme ">$Seq"
}
return
}
if {[regexp "/" $NomOuNumOuSortie]} {
set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
set Sortie $NomOuNumOuSortie
} else {
set Sortie ""
if { $NomOuNumOuSortie == "" } {
set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
} elseif { [regexp {^[a-zA-Z]} $NomOuNumOuSortie ] } {
set NomNum ${NomOuNumOuSortie}[NomDe ""]
} elseif { [regexp {^[0-9]} $NomOuNumOuSortie ] } {
set NomNum "[RepertoireDeTravail]/tmp.$NomOuNumOuSortie"
} else {
set NomNum "[RepertoireDeTravail]/tmp.[pid][NomDe ""]"
set Sortie $NomOuNumOuSortie
}
}
set Tmp $NomNum
set In "$Tmp"
set Out "$In.blastp"
set Log "$Out.log"
Sauve [SequenceFormatTFA $Sequence] dans $In
if {$Sortie==""} { set AskOrNot "" } else { set AskOrNot "DontAsk" }
if { $Programme == "P" } {
if {$Banque==""} { set Banque "/catalog/blast/protall" }
set Prog "blastp"
} elseif { $Programme == "N" } {
if {$Banque==""} { set Banque "/catalog/blast/genembl" }
set Prog "blastn"
} elseif { $Programme == "X" } {
if {$Banque==""} { set Banque "/catalog/blast/protein" }
set Prog "blastx"
} elseif { $Programme == "tN" } {
if {$Banque==""} { set Banque "/catalog/blast/genomes" }
set Prog "tblastn"
} elseif { $Programme == "Choix" } {
set Prog ""
} else {
set Prog [ChoixParmi "blastp" "tblastn" "blastx" "blastn"]
}
set Commande [ChoisisTonBlast $In $Out $Prog $Banque $AskOrNot]
if {$Commande==""} { return "" }
if {$Sortie!=""} {
regsub {^.*batchcom.tcl *} $Commande "" Commande
set Etat [eval $Commande]
if { ! [file exists $Out]} { return "" }
if {$Sortie=="retourne"} { return [ContenuDuFichier $Out] }
File copy -force $Out $Sortie
return $Sortie
}
Espionne $Commande
if {[catch {set Canal [open "| $Commande"]} Message]} {
Warne $Message
}
fconfigure $Canal -blocking false -buffering line
fileevent $Canal readable "ClosCanalEtMontreBlaste $Canal $Out"
Warne "Blast $Programme lance en batch"
}
proc BlastXdeADN {Nom DebutBlastX FinBlastX} {
global Commandes
global ADN TDN RAC
global NePlusFaireBlastX
global RepertoireDuGenome
if { ! [info exists NePlusFaireBlastX]} { set NePlusFaireBlastX 1 }
if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
if { $NePlusFaireBlastX || ! [OuiOuNon "Je lance BlastX ?"]} {
return "a faire."
}
if { ! [info exists ADN]} { ChargeADNetTDNetRAC }
if { [regexp {^[XFR]$} $Nom] } {
if { [regexp {^[XF]$} $Nom] } {
set Orient "F"
} else {
set Orient "R"
}
} else {
set Orient [Box $Nom orient]
if { $Orient == "" } {
FaireLire "$Nom n'est pas vraiment autorise\nen tant que debut de nom de sequence"
set Orient "F"
}
}
set NomDeLaSequence "${Nom}_${DebutBlastX}_${FinBlastX}"
set Sequence ">$NomDeLaSequence\n[BoutADN $DebutBlastX $FinBlastX $Orient]"
if { [regexp {^[XFR]$} $Nom] } {
Sauve $Sequence dans "$RepertoireDuGenome/tmpdir/$NomDeLaSequence"
}
set Num [NomDe ""]
set Tmp tmp.[pid]$Num
set In "$Tmp.BlastX.in"
set Out "$Tmp.BlastX"
set Log "$Out.log"
Sauve [SequenceFormatTFA $Sequence] dans $In
catch {set Canal [open "| $Commandes(blastx) $In $Out $Log"]} Message
Warne $Message
fconfigure $Canal -blocking false -buffering line
fileevent $Canal readable "ClosCanalEtMontreBlaste $Canal $Out $Log"
Warne "BlastX est lance en batch"
return "est lance sur $NomDeLaSequence"
}
proc VerifieAgam {} {
global LesSequencesDuTFAs
foreach Ligne [LesLignesDuFichier "/genomics/link/Agam/banques/AGAM"] {
if { ! [regexp {^>(.*?)( |$)} $Ligne Tout Access]} { continue }
lappend TousLesAccess $Access
}
set TousLesAccess [lsort $TousLesAccess]
set LesAccess [LaSequenceDuTFAs "/genomics/link/Agam/banques/AGAM" "LaListeDesAccess" "" "" "ForceAccessFirst"]
Espionne [llength [array names LesSequencesDuTFAs]]
set LesAccess [lsort $LesAccess]
SauveLesLignes $TousLesAccess dans tla
SauveLesLignes $LesAccess dans la
Espionne "[llength $TousLesAccess] [llength [lsort -unique $TousLesAccess]] [llength $LesAccess] [llength [lsort -unique $LesAccess]]"
exit
foreach Access $LesAccess {
set TFA($Access) [LaSequenceDuTFAs "/genomics/link/Agam/banques/AGAM" $Access ]
}
foreach Fichier [lsort [glob "/genomics/link/Agam/prottfa/*"]] {
set Nom [file tail $Fichier]
set Entete [EnteteDuFichierTFA $Fichier]
set Access [lindex [split $Entete " "] 1]
if { 0 && ! [info exists TFA($Access)]} { FaireLire "$Entete" }
# Espionne "$Nom $Access"
set Agam($Access) $Nom
}
foreach Access $LesAccess {
if { ! [info exists Agam($Access)]} { FaireLire "$Access" }
}
}
proc CreeFOF {{Rep ""}} {
set Projet [file tail [RepertoireDuGenome]]
if {$Rep==""} { set Rep "[RepertoireDuGenome]/nuctfa" }
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
if {$Alias==""} { set Alias $Nom }
set Source "$Rep/$Nom"
lappend LeFOF "$Alias $Source"
}
return [SauveLesLignes $LeFOF dans "[RepertoireDuGenome]/$Projet.fof"]
}
proc AppendFOF {{Rep ""} {NewRep ""} {FichierFOF ""}} {
Wup "Takes all TFA files from Rep and creates a normalised version with the PS as access"
if {$FichierFOF==""} {
set Projet [file tail [RepertoireDuGenome]]
set FichierFOF "[RepertoireDuGenome]/$Projet.fof"
}
if {$Rep==""} { set Rep [ChoixDuRepertoire "[RepertoireDuGenome]/"] }
if { ! [regexp "^/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
if {$NewRep==""} {
set NewRep "[file dirname $Rep]/NewTFA"
}
if { ! [regexp "^/" $NewRep]} { set NewRep "[RepertoireDuGenome]/$NewRep" }
if {[FileAbsent $NewRep]} { file mkdir $NewRep }
Espionne $Rep
foreach Fichier [lsort [glob -nocomplain "$Rep/*"]] {
Espionne $Fichier
set Queue [file tail $Fichier]
regsub {^[A-Z]+_[^_]+_} $Queue "" PS
set Entete [EnteteDuFichierTFA $Fichier]
set Seq [QueLaSequenceDuFichierTFA $Fichier]
regsub {>[^ ]+ } $Entete "" DE
set TFA [SequenceFormatTFA $Seq "$PS $DE" "nucbrut"]
Espionne $TFA
set FicTFA "$NewRep/$Queue"
Sauve $TFA dans $FicTFA
lappend LeNouveauFOF "$PS $FicTFA"
}
if {[file exists $FichierFOF]} { Garde $FichierFOF }
AppendAuFichier $FichierFOF [join $LeNouveauFOF "\n"]
return $FichierFOF
}
proc FragFrom {Nom {Start ""} {StopVoulu ""}} {
if {$Start==""} { set Start [Entre 1] }
if {$StopVoulu==""} { set StopVoulu 999999 }
scan $Start "%d %d" Start StopVoulu
set Seq "n[QueLaSequenceDuFichierTFA [GscopeFile $Nom nuctfa]]"
set Frag [string range $Seq $Start end]
set Stop [expr $Start+2]
set YaStop 0
set NewNuc ""
foreach {A B C} [split "${Frag}zzz" ""] {
if {$C=="z"} { break }
set Codon "$A$B$C"
append NewNuc $Codon
if {[CodonStopPossible $Codon]} {
if {$Stop<$StopVoulu && [OuiOuNon "I found a Stop at $Stop < your stop $StopVoulu\nDo I ignore it ?"]} {
} else {
set YaStop 1
break
}
}
if {$StopVoulu<=$Stop} { break }
incr Stop 3
}
set Entete "$Nom-$Start-$Stop"
if { ! $YaStop} { append Entete " stop not in the original sequence" }
set NewPro [SeqNucToSeqPro $NewNuc]
set ProTFA [SequenceFormatTFA $NewPro $Entete "protbrut"]
set NucTFA [SequenceFormatTFA $NewNuc $Entete "nucbrut"]
regsub -all " " $Entete "_" E
set FN [AfficheVariable $NucTFA "AvecFormate" "Nucleic_Fragment_of_$E"]
set FP [AfficheVariable $ProTFA "AvecFormate" "Proteic_Fragment_of_$E"]
return $FN
}
proc NewGenes {FichierListe {RepDestin ""} {FOF ""}} {
Wup "Copies the A.nuctfa to proteome/A if RepDestin contains proteome"
Wup " doesn't copy if RepDestin is else (and keeps .nuctfa)"
Wup "Appends to .fof"
if {[file tail [pwd]]!=[file tail [RepertoireDuGenome]]} {
if {[OuiOuNon "It's better to be at the top of the Gscope Database\nDo I cd [RepertoireDuGenome]?"]} {
cd [RepertoireDuGenome]
}
}
if {$RepDestin==""} { set RepDestin "[RepertoireDuGenome]/proteome" }
if {$FOF==""} {
set PossibleFOF [lindex [glob -nocomplain "[RepertoireDuGenome]/*.fof"] 0]
set FOF [ButineArborescence "All" $PossibleFOF]
}
foreach Ligne [LesLignesDuFichier $FichierListe] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s" A
set NomDejavu [NomDuAlias $A]
if {$NomDejavu!=""} {
if {[OuiOuNon "$A already exists as $NomDeJaVu\nDo I skipp ?"]} { continue }
if {[OuiOuNon "$A already exists as $NomDeJaVu\nDo I cancel ?"]} { return }
}
set Source "./$A.nuctfa"
if {[FileAbsent $Source]} {
if {[OuiOuNon "$Source doen't exist \nDo I skipp ?"]} { continue }
if {[OuiOuNon "$Source doen't exist \nDo I cancel ?"]} { return }
}
if {[regexp proteome $RepDestin]} {
set Destin "[RepertoireDuGenome]/proteome/$A"
if {[FileExists $Destin]} {
if {[OuiOuNon "$Destin already exists \nDo I skipp ?"]} { continue }
if {[OuiOuNon "$Destin already exists \nDo I cancel ?"]} { return }
}
file copy $Source $Destin
} else {
set Destin $Source
}
set New "$A $Destin"
Espionne $New
AppendAuFichier $FOF $New
lappend LesNews $New
}
return $LesNews
}
proc LesPABsDuTFAs {Fichier {Rep ""}} {
if { ! [OuiOuNon "Ok to create all nuctfa files and to replace fiches/bornesdespabs" 0]} { return "" }
if {$Rep==""} { set Rep "[RepertoireDuGenome]/nuctfa" }
if { ! [file exists $Rep]} { file mkdir $Rep }
set PF [PreFixe]
set Numero 0
set Debut 101
set Frame [expr $Debut%3]
foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
incr Numero
set BeauNumero [format "%5.5d" $Numero]
set Nom "$PF$BeauNumero"
set TFA [LaSequenceDuTFAs $Fichier $Access]
set FicTFA "$Rep/$Nom"
set Ent [EnteteDuTexteTFA $TFA]
set Seq [QueLaSequenceDuTexteTFA $TFA]
set Long [string length $Seq]
set NouveauTFA [SequenceFormatTFA $Seq "$Nom $Ent" nucbrut]
Sauve $NouveauTFA dans $FicTFA
set Fin [expr $Debut+$Long-1]
set Bornes "$Nom $Debut $Fin F"
lappend LesBornes $Bornes
set Debut [expr (($Fin + 1000)/3)*3 + $Frame]
}
return [SauveLesLignes $LesBornes dans "[RepertoireDuGenome]/fiches/bornesdespabs"]
}
proc NettoieTriBlast {} {
foreach Nom [ListeDesPABs] {
set F "[RepertoireDuGenome]/protembl/$Nom"
regsub {\: \>} [ContenuDuFichier $F] "" TFA
Espionne [Sauve $TFA dans $F]
}
exit
}
proc CheckCompletion {Qui {Quoi ""}} {
global CheckCompletion
if {$Quoi=="Signification"} { return $CheckCompletion($Qui) }
if {$Quoi=="Color"} {
set CC [CheckCompletion $Qui]
set OK [CheckCompletion StatOk]
if {$CC==$OK} {
set CheckCompletion(green) "CheckCompletion Ok"
return "green"
} else {
set CheckCompletion(red) "CheckCompletion no copplete"
return "red"
}
}
if {[info exists CheckCompletion($Qui)]} { return $CheckCompletion($Qui) }
if {[info exists CheckCompletion("EstCharge")]} { return $CheckCompletion("EstCharge") }
set LesReps [list \
prottfa \
blastp \
daedalushits \
msf \
msfLeon \
macsimXml \
]
foreach Nom [ListeDesPABs] {
set N 1
set Status 0
set StatOk 0
foreach Rep $LesReps {
set Fichier "[RepertoireDuGenome]/$Rep/$Nom"
if {[file exists $Fichier]} { incr Status $N }
incr StatOk $N
set CheckCompletion($StatOk) $Rep
set CheckCompletion($Rep) $StatOk
set N [expr $N*2]
}
set CheckCompletion(StatOk) $StatOk
set CheckCompletion($Nom) $Status
}
set CheckCompletion("EstCharge") -1
return [CheckCompletion $Qui]
}
proc AliasDansTfaPourTous {} {
if { ! [OuiOuNon "This proc read the 'alias' in the prottfa file.\n\
Please verify the source sode if it corresponds to what you need\n\
Do I continue ?"]} { return }
foreach Nom [ListeDesPABs] {
set FichierTfa "[RepertoireDuGenome]/prottfa/$Nom"
if { ! [file exists $FichierTfa]} { continue }
set Ent [EnteteDuFichierTFA $FichierTfa]
if {[OuiOuNonMemo "Do I take the second word of the tfa file as the Alias?"]} {
set A ""
scan $Ent "%s %s" CN A
regsub ">" $CN "" NomLu
if {$NomLu!=$Nom} { FaireLire "$Nom has following line\n$Ent" }
InformeSansDemander $Nom "Alias: $A"
continue
}
continue
set Seq [QueLaSequenceDuFichierTFA $FichierTfa]
set BonTFA [SequenceFormatTFA [string toupper $Seq] "$Nom $A" "protbrut"]
Espionne [Sauve $BonTFA dans $FichierTfa]
}
}
proc NearestOrganismsHit Nom {
global NearestOrganismsHit
if {[info exists NearestOrganismsHit($Nom)]} { return $NearestOrganismsHit($Nom) }
if {[info exists NearestOrganismsHit("EstCharge")]} { return $NearestOrganismsHit("EstCharge") }
set NearestOrganismsHit("EstCharge") -1
set Fichier "[RepertoireDuGenome]/fiches/danslafamille1"
if { ! [file exists $Fichier]} { set NearestOrganismsHit("EstCharge") -2 ; return -2 }
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s %d" NomLu Valeur
set NearestOrganismsHit($NomLu) $Valeur
}
return [NearestOrganismsHit $Nom]
}
proc LesMauvaisInfos {} {
foreach Nom [ListeDesFusions] {
if { ! [EstUneFusion $Nom]} { continue }
set Fusion [Fusion $Nom]
if {[regexp "/" $Fusion]} {Informe $Nom}
continue
Espionne "\n\n\nFusion $Fusion"
foreach Fus [split $Fusion "/"] {
set NomA [StringApres "obtained by fusion of " dans $Fus]
set PartA [ExtraitInfo $NomA "PartAofFusion"]
Espionne "$NomA est PartA \n$PartA"
set Double [StringSuivant "obtained by fusion of " dans $Fus]
set BonneA [StringSuivant "obtained by fusion of " dans $PartA]
if {$BonneA==$Double} { continue }
Espionne "Je sucre $Fus"
continue
if {[regexp "because frameshift between" $Fus]} {
set NomB [StringApres "obtained by fusion of $NomA and " dans $Fus]
set PartB [ExtraitInfo $NomB "PartBofFusion"]
Espionne "$NomB est PartB \n$PartB"
}
}
}
}
proc ListeDesFusions {} {
global ListeDesFusions
global ListeDeBoites
if {[info exists ListeDesFusions]} { return $ListeDesFusions }
set FichierBornesDesFusions "[RepertoireDuGenome]/fiches/bornesdesfusions"
if { ! [file exists $FichierBornesDesFusions]} {
set ListeDesFusions {}
return $ListeDesFusions
}
foreach Ligne [LesLignesDuFichier $FichierBornesDesFusions] {
if { ! [regexp -nocase {[a-z]} $Ligne]} {continue}
ExtraireDe $Ligne Nom Debut Fin Orient
Box $Nom nom $Nom
Box $Nom debut $Debut
Box $Nom fin $Fin
Box $Nom orient $Orient
if {$Orient=="F"} {
Box $Nom frame "T"
} else {
Box $Nom frame "t"
}
lappend ListeDesFusions $Nom
lappend ListeDeBoites $Nom
}
return $ListeDesFusions
}
proc Fusion Nom {
return [ExtraitInfo $Nom "Fusion"]
}
proc EstUneFusion Nom {
return [expr ! [string equal [Fusion $Nom] ""]]
Wup "Rest is obsolete"
if {$Nom>="MS50000"} { return 1 } else { return 0 }
}
proc InformeLaFusionAvecProttfaPourTous {} {
foreach Nom [ListeDesFusions] {
if { ! [EstUneFusion $Nom]} { continue }
set Info [InformeLaFusionAvecProttfa $Nom]
Espionne "$Nom\n$Info"
}
}
proc InformeLaFusionAvecProttfa Nom {
set Fichier "[RepertoireDuGenome]/prottfafusion/$Nom"
if { ! [file exists $Fichier]} { return "" }
set Entete [EnteteDuFichierTFA $Fichier]
regsub ">" $Entete "" Entete
regsub "$Nom " $Entete "" TexteF
set TexteF "Fusion: $TexteF"
set Info [InformeSansDemander $Nom $TexteF]
set A [StringApres "obtained by fusion of " dans $Entete]
set TexteA "PartAofFusion: $Entete"
InformeSansDemander $A $TexteA
if {[regexp "because frameshift between" $Entete]} {
set B [StringApres "obtained by fusion of $A and " dans $Entete]
set TexteB "PartBofFusion: $Entete"
InformeSansDemander $B $TexteB
}
return $Info
}
proc LesOubliesParGscope {} {
foreach Nom [ListeDesPABs] {
set Fic "[RepertoireDuGenome]/msf/$Nom"
if { ! [file exists $Fic]} {
set MSF 0
} elseif {[regexp "NoSequence" [ContenuDuFichier $Fic]]} {
set MSF -1
} else {
set MSF 1
}
set Fic "[RepertoireDuGenome]/daedalushits/$Nom"
if { ! [file exists $Fic]} {
set DAE 0
} else {
set DAE 1
}
set Fic "[RepertoireDuGenome]/blastp/$Nom"
if { ! [file exists $Fic]} {
set BLA 0
} elseif {[regexp "No hits" [ContenuDuFichier $Fic]]} {
set BLA -1
} else {
set BLA 1
}
if {$MSF==1 && $DAE==1 && $BLA==1} { continue }
if {$BLA==0 && ($MSF!=0 || $DAE!=0)} {
lappend LesOublies "$Nom sans blast mais avec autre"
continue
PourVoir $Nom
}
if {$DAE==0 && $BLA==1} {
lappend LesOublies "$Nom sans daedalus mais avec blast"
continue
PourVoir $Nom
}
lappend LesOublies "$Nom $MSF $DAE $BLA"
}
return $LesOublies
}
proc DesNouvellesSequencesPourGscope Fichier {
Wup "Fichier contains a list of access, file names or a all TFAs sequences"
if {[regexp {^[\n ]*>} [ContenuDuFichier $Fichier]]} {
foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $Fichier $Access]
UneNouvelleSequencePourGscope $TFA "Auto"
lappend LesAccess $Access
}
return $LesAccess
}
set LesLignes [LesLignesDuFichier $Fichier]
foreach Ligne $LesLignes {
scan $Ligne "%s" Nouveau
UneNouvelleSequencePourGscope $Nouveau "Auto"
}
return $LesLignes
}
proc TestEstCeVraimentUneNouvelleSequence {{NP ""}} {
set TFA [ContenuDuFichier [GscopeFile PGS001 $NP]]
# append TFA "ATGATGATAG"
regsub {>[^ ]+} $TFA ">AR" TFA
Espionne [EstCeVraimentUneNouvelleSequence $TFA $NP]
}
proc EstCeVraimentUneNouvelleSequence {TFA {NucOuPro ""}} {
set Rep ""
if {[regexp "nuc" $NucOuPro]} { set Rep "nuctfa" }
if {[regexp "pro" $NucOuPro]} { set Rep "prottfa" }
set LesMemesAlias {}
set LesMemesSeq {}
set LesMemesAliasEtSeq {}
set SeqNouveau [QueLaSequenceDuTexteTFA $TFA]
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set Access [EnteteDuTexteTFA $TFA "access"]
set Seq [QueLaSequenceDuPAB $Nom $Rep]
set MemeAlias [string equal -nocase $Access $Alias]
set MemeSeq [string equal -nocase $Seq $SeqNouveau]
if {$MemeAlias} { set MemeAliasText "SameAlias" } else { set MemeAliasText "DifferentAlias" }
if {$MemeSeq} { set MemeSeqText "SameSeq" } else { set MemeSeqText "DifferentSeq" }
set Message "$Nom $Alias $Access $MemeAliasText $MemeSeqText"
if {$MemeAlias} { lappend LesMemesAlias $Message }
if {$MemeSeq} { lappend LesMemesSeq $Message }
if {$MemeAlias && $MemeSeq} { lappend LesMemesAliasEtSeq $Message }
}
if {$LesMemesAlias=={} && $LesMemesSeq=={}} { return 1 }
set FA ""; set FS ""; set FX ""
if {$LesMemesAlias!={}} { set FA [AfficheListe $LesMemesAlias "" "SameAlias"] }
if {$LesMemesSeq !={}} { set FS [AfficheListe $LesMemesSeq "" "SameSequence"] }
if {$LesMemesAlias!={} && $LesMemesSeq!={}} { set FX [AfficheListe $LesMemesAliasEtSeq "" "SameAliasAndSequence"] }
set Reponse [OuiOuNon "The new sequence exists already \n\
Please find the hits in the displayed lists\nDo I use it as a new sequence"]
if {$FA!=""} { destroy $FA }
if {$FS!=""} { destroy $FS }
if {$FX!=""} { destroy $FX }
return $Reponse
}
proc UneNouvelleSequencePourGscope {{Nouveau ""} {Maniere ""}} {
if {$Maniere==""} { set Maniere "Ask" }
if {$Nouveau==""} {
# if { ! [OuiOuNon "Do You want to add a new sequence to the GscopeDatabase ?"]} { return "" }
FaireLire "Please enter the sequence or its access or its file name ..."
}
set Seq [SeqIn $Nouveau]
set Format [FormatDeLaSequence $Seq]
set EMBL ""
if {[regexp "embl" $Format]} {
set EMBL $Seq
if {$Maniere!="Auto"} {
AfficheVariable $EMBL "AvecChangeFormat" "Your sequence in EMBL format"
}
}
set TFA [SequenceFormatTFA $Seq "" $Format]
if {$Maniere!="Auto"} {
while 1 {
FaireLire "Please verify (and/or edit) the TFA sequence"
set BonTFA [EntreTexte $TFA]
if {$BonTFA!=""} { set TFA $BonTFA ; break }
if {[OuiOuNon "Do you want to edit it again ?"]} { continue }
if { ! [OuiOuNon "Do we cancel ?"]} { return "" }
return [UneNouvelleSequencePourGscope $Nouveau]
}
while {$EMBL!=""} {
set SeqTFA [QueLaSequenceDuTexteTFA $TFA]
set SeqEMBL [QueLaSequenceDuTexteEMBL $EMBL]
if {[string equal -nocase $SeqTFA $SeqEMBL]} { break }
if {[OuiOuNon "The original EMBL sequence doesn't correspond to the TFA sequence.\n\
Do I forget the original EMBL sequence ?"]} { set EMBL "" ; break }
if {[OuiOuNon "The original EMBL sequence doesn't correspond to the TFA sequence.\n\
Do we cancel UneNouvelleSequencePourGscope ?"]} { return "" }
}
}
if {[regexp -nocase "P" [NucOuProt $TFA]]} {
set NucOuProt "prot"
} else {
set NucOuProt "nuc"
}
set ExisteDeja [EstCeVraimentUneNouvelleSequence $TFA $NucOuProt]
set LongS [string length [QueLaSequenceDuTexteTFA $TFA]]
if {[regexp -nocase "P" $NucOuProt]} { set LongN [expr $LongS*3] } else { set LongN $LongS }
set Dernier [DernierPAB "EnNumero"]
regsub -all -nocase {[A-Z_]} $Dernier "" Numero
set N [Base10 $Numero]
incr N
set NouveauNom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $N]
if {$Maniere!="Auto"} {
while 1 {
set NouveauNom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $N]
if {[OuiOuNon "Do I use $NouveauNom ?"]} { break }
set NouveauNom [Entre $NouveauNom]
if {$NouveauNom!=""} { break }
}
}
set AncienNom [Box $NouveauNom nom]
set AncienDeb [Box $NouveauNom debut]
set AncienFin [Box $NouveauNom fin]
set AncienOri [Box $NouveauNom orient]
if {$AncienNom!=""} {
set Nom $AncienNom
set Debut $AncienDeb
set Fin $AncienFin
set Orient $AncienOri
} else {
set DernierPosition [DernierPAB "EnPosition"]
set FinActuelle [Box $DernierPosition fin]
set Nom $NouveauNom
set Debut [expr $FinActuelle +100]
set Fin [expr $Debut + $LongN]
set Orient "F"
}
set Borne "$Nom $Debut $Fin $Orient"
if {$Maniere!="Auto"} {
while { ! [OuiOuNon "Ok to use $Borne ?"]} {
set NouvelleBorne [Entre $Borne]
if {$NouvelleBorne==""} { continue }
set Borne $NouvellesBorne
}
}
scan $Borne "%s %d %d %s" Nom Debut Fin Orient
MiseAJourBornesDesPABs $Borne
set LesExistants [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"]
if {$Maniere!="Auto"} {
if {$LesExistants!={}} {
FaireLire "Please select the OLD files I have to delete"
set LesEffacables [MorceauxChoisis $LesExistants]
foreach Effacables $LesEffacables {
file delete $Effacables
}
}
}
set FichierTFA "[RepertoireDuGenome]/${NucOuProt}tfa/$Nom"
if { $Maniere=="Auto" || \
! [file exists $FichierTFA] || [OuiOuNon "Ok to overwrite $FichierTFA ?"]} {
set Rep "[RepertoireDuGenome]/${NucOuProt}tfa"
if { ! [file exists $Rep]} { file mkdir $Rep }
Sauve $TFA dans $FichierTFA
}
if {$EMBL!=""} {
set Rep "[RepertoireDuGenome]/${NucOuProt}embl"
if { ! [file exists $Rep]} { file mkdir $Rep }
set FichierEMBL "$Rep/$Nom"
if { $Maniere=="Auto" || \
! [file exists $FichierEMBL] || [OuiOuNon "Ok to overwrite $FichierEMBL ?"]} {
Sauve $EMBL dans $FichierEMBL
}
}
return "$Nom $Debut $Fin $Orient"
}
proc HistogrammeDuCAI {} {
foreach Nom [ListeDesPABs] {
set x [CAI $Nom]
if {$x!=""} {
lappend LesCAI [expr round (100*$x)]
}
}
Histogramme $LesCAI Graphe
}
proc CodonW {} {
global RepertoireDuGenome
set TFA [CreeTfaPourCodonw]
set RepCodonw "$RepertoireDuGenome/codonw"
set FichierCAI "$RepCodonw/cai.def"
if { ! [file exists $FichierCAI]} {
Sauve "$TFA\n$FichierCAI" dans "$RepCodonw/cai.input"
catch {exec cai < "$RepCodonw/cai.input" >& "$RepCodonw/cai.log"}
if { ! [file exists $FichierCAI]} {
FaireLire "Problem with cai. I could'nt create $FichierCAI\nDid You setcodonw ?"
return ""
}
}
return $FichierCAI
}
proc CAI Nom {
global RepertoireDuGenome
global CAI
if {[info exists CAI($Nom)]} { return [set CAI($Nom)] }
if {[info exists CAI("EstCharge")]} { return "" }
set CAI("EstCharge") 1
set CAI(LaListeMerci) {}
set FichierCAI "$RepertoireDuGenome/codonw/cai.def"
if { ! [file exists $FichierCAI]} { return "" }
foreach Ligne [LesLignesDuFichier $FichierCAI] {
set x ""
scan $Ligne "%s %f" NomLu x
if {$x==""} { continue }
set CAI($NomLu) $x
lappend CAI(LaListeMerci) $x
}
if {[info exists CAI($Nom)]} { return [set CAI($Nom)] }
return ""
}
proc CreeTfaPourCodonw {} {
global RepertoireDuGenome
set RepCodonw "$RepertoireDuGenome/codonw"
if { ! [file exists $RepCodonw]} { File mkdir $RepCodonw }
set TFA "$RepCodonw/[string tolower [PreFixe]].tfa"
if { ! [OuiOuNon "$TFA\nwill be the name of the tfa file with all nuc. sequences. OK ?" 1]} {
set TFA [Entre $TFA]
if {$TFA==""} { return "" }
}
if {[file exists $TFA]} {
if { ! [OuiOuNon "$TFA already exists. Do I replace it ?" 0]} { return $TFA }
File delete $TFA
}
foreach Nom [ListeDesPABs] {
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
if {$Orient=="F"} {
incr Fin 3
} else {
incr Debut -3
}
if {[OuiOuNonMemo "Do I use the genome DNA file for CodonW?"]} {
set TFAduPAB ">$Nom\n[SequenceFormatBrut [BoutADN $Debut $Fin $Orient]]"
} else {
set Rep [RepDesNucPourCodonW]
set TFAduPAB [ContenuDuFichier [GscopeFile $Nom $Rep]]
}
AppendAuFichier $TFA $TFAduPAB
}
return $TFA
}
proc RepDesNucPourCodonW {} {
global RepDesNucPourCodonw
if {[info exists RepDesNucPourCodonw]} { return $RepDesNucPourCodonw }
set LesPossibles {}
foreach Rep [lsort [glob -type d "[RepertoireDuGenome]/*"]] {
lappend LesPossibles [file tail $Rep]
}
FaireLire "Please chose the directory containing the nuctfa for CodonW"
set RepDesNucPourCodonw [ChoixParmi $LesPossibles]
return $RepDesNucPourCodonw
}
proc AffymetrixAccess Nom {
return [ExtraitInfo $Nom "AffymetrixAccess"]
}
proc OwnerOfCDNA Nom {
return [ExtraitInfo $Nom "OwnerOfCDNA"]
}
proc CodeClone Nom {
return [ExtraitInfo $Nom "CodeClone"]
}
proc InformeIdentitesDuCDNAPourTous {} {
foreach Nom [ListeDesPABs] {
Espionne [InformeIdentitesDuCDNA $Nom]
}
}
proc InformeIdentitesDuCDNA Nom {
global RepertoireDuGenome
set FichierTFA "$RepertoireDuGenome/nuctfa/$Nom"
if { ! [file exists $FichierTFA]} { return "" }
set CC ""
set Ow ""
set Entete [PremiereLigneDuFichier $FichierTFA]
if {[OnTraiteDesAffymetrix]} {
scan $Entete "%s %s" NomLu AC
set NomAccesAliases [lindex [split $Entete ":"] 0]
set Definition [lindex [split $Entete ":"] 1]
set LesAliases [lrange [split $NomAccesAliases " "] 2 end]
set CC "[join $LesAliases " "]"
InformeSansDemander $Nom "=AffymetrixAccess: $AC"
InformeSansDemander $Nom "=OwnerOfCDNA: Affymetrix"
InformeSansDemander $Nom "=GBtagsDefinition: $Definition"
} else {
scan $Entete "%s %s %s" NomLu CC Ow
if {$Ow!=""} { InformeSansDemander $Nom "=OwnerOfCDNA: $Ow" }
if {$CC==""} { return "" }
}
return [InformeSansDemander $Nom "=CodeClone: $CC"]
}
proc BlastDesHitsHumainsDuProfil {} {
set Rep "[RepertoireDuGenome]/blastpDesHitsHumainsDuProfil"
if { ! [file exists $Rep]} { file mkdir $Rep }
set Texte [ContenuDuFichier "/home/brelivet/multi_align/alignment/Profile/Homo_sapiens.DaedalusHits"]
set BlastPDataBase "[RepertoireDuGenome]/banques/AllNR"
while {[set BH [ValeurDeLaBalise "BlastHit" Texte]]!=""} {
set AC [ValeurDeLaBalise AC BH NePasRogner]
set ID [ValeurDeLaBalise ID BH NePasRogner]
set DE [ValeurDeLaBalise DE BH NePasRogner]
set EMBL [SequenceDesBanques $ID]
if {$EMBL==""} { FaireLire "I can't find \n$BH" ; continue }
set TFA [SequenceFormatTFA $EMBL "$ID $AC $DE" "embl"]
set FichierBlast "$Rep/$ID.blastp"
set FichierTFA [Sauve $TFA dans "[TmpFile].tfa"]
set CommandeBlast "blastall \
-p blastp \
-i \$FichierTFA \
-o \$FichierBlast.encours \
-d $BlastPDataBase \
-v 100 \
-K 0 \
-b 100 \
-e 10.0 \
-F T"
Espionne "$ID $AC $DE"
eval exec $CommandeBlast
if {[file exists $FichierBlast.encours]} { file rename -force $FichierBlast.encours $FichierBlast }
}
exit
}
proc CompareChroContLoc {LigneA LigneB} {
scan $LigneA "%s %s %d" ChA CoA DebA
scan $LigneB "%s %s %d" ChB CoB DebB
if {$ChA<$ChB} { return -1 }
if {$ChA>$ChB} { return 1 }
if {$CoA<$CoB} { return -1 }
if {$CoA>$CoB} { return 1 }
if {[expr $DebA<$DebB]} { return -1 }
if {[expr $DebA>$DebB]} { return 1 }
return 0
}
proc SeqElong {} {
foreach Access [LesLignesDuFichier "[RepertoireDuGenome]/DeStephane/AccessElongases.list"] {
set LEmbl [LaSequenceDesBanques $Access]
if {$LEmbl=={}} { continue }
Espionne [SauveLesLignes $LEmbl dans "$Access.embl"]
set TFA [SequenceFormatTFA [join $LEmbl "\n"] "$Access" "embl"]
Espionne [Sauve $TFA dans "$Access.tfa"]
}
exit
}
proc SameOrganism {Organisme Famille {SansGlossaire ""}} {
if {[llength $Famille]>1 && [regexp " " [lindex $Famille 0]]} {
set Famille [join $Famille ":"]
}
Espionne $Famille
if {[regexp {(\||\&)} $Organisme Separateur]} {
set AuMoinsUN 0
foreach O [split $Organisme $Separateur] {
if {$O==""} { continue }
set Courant [SameOrganism $O $Famille $SansGlossaire]
if { $Courant && $Separateur=="|"} { return 1 }
if { ! $Courant && $Separateur=="&"} { return 0 }
set AuMoinsUn 1
}
return $AuMoinsUn
}
if {$SansGlossaire!="SansGlossaire"} { set Organisme [Glossaire $Organisme "Complet"] }
return [regexp "\:$Organisme\:" ":$Famille:"]
}
proc MoveLesReMask {} {
foreach F [glob -nocomplain *] {
regsub ".remask" $F ".rm" D
Espionne "file rename $F ../nucmask/$D"
file rename $F "../nucmask/$D"
}
}
proc AliasParNomDuFichier {} {
set FichierFOF [ButineArborescence All "[RepertoireDuGenome]"]
foreach Ligne [LesLignesDuFichier $FichierFOF] Nom [ListeDesPABs] {
scan $Ligne "%s %s" AliasLu FicLu
set Nouveau [file tail $FicLu]
if {0 && [Alias $Nom]!=$AliasLu} {
FaireLire "Attention pour $Nom $AliasLu != [Alias $Nom]"
}
Espionne "InformeSansDemander $Nom =Alias: $Nouveau"
InformeSansDemander $Nom "=Alias: $Nouveau"
}
exit
}
proc Taxonomy Nom {
return [ExtraitInfo $Nom "Taxonomy"]
}
proc OrganismeFormate {Organisme {Format ""}} {
Wup "Format can be All TaxIds TaxId Name Names NamesList NamesPlus NamesDDot"
if {$Format=="" || $Format=="All" } { return $Organisme }
if {$Format=="Names"} { set Format "NamesList" }
if {$Format=="TaxId"} {
if {[regexp {^[0-9]+} $Organisme]} {
scan $Organisme "%d" TaxId
return $TaxId
} else {
return [Tax $Organisme TaxId]
}
}
if {$Format=="TaxIds"} {
if {[regexp {^[0-9]+} $Organisme]} {
if {[regexp -indices {[^0-9 ]} $Organisme Indices]} {
set I [lindex $Indices 0]
set TexteId [string range $$Organisme 0 [incr I -1]]
return [string trim $TexteId]
} else {
return $Organisme
}
} else {
return [Tax $Organisme "TaxId"]
}
}
if {$Format=="Name"} {
if {[regexp -nocase {^[a-z]} $Organisme]} {
if {[regexp -indices {\:\+} $Organisme Indices]} {
set I [lindex $Indices 0]
set TexteName [string range 0 [incr I -1]]
return [string trim $TexteName]
}
return $Organisme
}
if {[regexp "<" $Organisme]} {
set Texte [TexteEntreChevrons $Organisme]
if {[regexp "<" $Organisme]} {
return [TexteEntreChevrons $Texte]
} else {
return $Texte
}
}
if {[regexp {^[0-9]+} $Organisme]} {
scan $Organisme "%d" TaxId
return [Tax $TaxId "Name"]
}
regsub -all -nocase {[^a-z ]} $Organisme "" Name
return $Name
}
if {[regexp "Names" $Format]} {
if {[regexp -nocase {^[a-z]} $Organisme]} {
if {[regexp {\:\+} $Organisme Match]} {
set LesNames [split $Organisme $Match]
if {$Format=="NamesList"} { return $LesNames }
if {$Format=="NamesPlus"} { return [join $LesNames "+"] }
if {$Format=="NamesDDot" } { return [join $LesNames ":"] }
} else {
if {$Format=="NamesList"} { return [list $Organisme] }
if {$Format=="NamesPlus"} { return $Organisme }
if {$Format=="NamesDDot" } { return $Organisme }
}
FaireLire "Erreur appel OrganismeFormate $Organisme $Format"
return [Entre $Organisme]
}
if {[regexp "<" $Organisme]} {
set Texte [TexteEntreChevrons $Organisme]
if {[regexp {\+} $Texte]} {
set LesNames {}
foreach OrChev [split $Texte "+"] {
lappend LesNames [TexteEntreChevrons $OrChev]
}
if {$Format=="NamesList"} { return $LesNames }
if {$Format=="NamesPlus"} { return [join $LesNames "+"] }
if {$Format=="NamesDDot"} { return [join $LesNames ":"] }
} else {
if {$Format=="NamesList"} { return [list [TexteEntreChevrons $Texte]] }
if {$Format=="NamesPlus"} { return [TexteEntreChevrons $Texte] }
if {$Format=="NamesDDot"} { return [TexteEntreChevrons $Texte] }
}
FaireLire "Erreur appel OrganismeFormate $Organisme $Format"
return [Entre $Organisme]
}
set Reste $Organisme
set LesNames {}
while {[regexp {^[0-9]+} $Reste]} {
scan $Reste "%d" TaxId
lappend LesNames [Tax $TaxId "Name"]
regsub " *$TaxId *" $Reste "" Reste
}
if {$Format=="NamesList"} { return $LesNames }
if {$Format=="NamesPlus"} { return [join $LesNames "+"] }
if {$Format=="NamesDDot"} { return [join $LesNames ":"] }
}
FaireLire "Erreur appel OrganismeFormate $Organisme $Format"
return [Entre $Organisme]
}
proc OrganismeDuPAB {Nom {Format ""}} {
global OrganismeDuPAB
Wup "Format is not used ... a developper"
if {$Format==""} { set Format "All" }
if {$Nom=="Reload"} {
if {[info exists OrganismeDuPAB]} { unset OrganismeDuPAB }
set Nom "turlututu"
}
if {[info exists OrganismeDuPAB($Nom)]} { return [OrganismeFormate [set OrganismeDuPAB($Nom)] $Format] }
if {[info exists OrganismeDuPAB("EstCharge")]} { return [set OrganismeDuPAB("EstCharge")] }
set FichierOrganismesDesPABs "[RepertoireDuGenome]/fiches/organismesdespabs"
if {[NotreOS]=="" || [NotreOS]=="Inconnu inconnu"} {
set OrganismeDuPAB("EstCharge") "Inconnu inconnu"
} else {
set OrganismeDuPAB("EstCharge") [NotreOS]
}
if {[file exists $FichierOrganismesDesPABs] \
&& [regexp "SeeInfo" [PremiereLigneDuFichier $FichierOrganismesDesPABs]]} {
foreach PAB [ListeDesPABs] {
set Org [ExtraitInfo $PAB "Organism"]
# if {$Org==""} { set Org "Inconnnu inconnu" }
set OrganismeDuPAB($PAB) $Org
}
return [OrganismeDuPAB $Nom $Format]
}
if {[file exists $FichierOrganismesDesPABs]} {
set OrganismeDuPAB("EstCharge") [Glossaire "Inconnu inconnu" Complet]
foreach Ligne [LesLignesDuFichier $FichierOrganismesDesPABs] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
set NomLu ""
scan $Ligne "%s" NomLu
set Organisme ""
regsub " *$NomLu +" $Ligne "" Organisme
set OrganismeDuPAB($NomLu) $Organisme
}
return [OrganismeDuPAB $Nom $Format]
}
return [OrganismeDuPAB $Nom $Format]
}
proc QuiManque {} {
set LesReps [list prottfa blastp tfasdescopains aliinout msf]
foreach Nom [ListeDesPABs] {
set Message "$Nom"
foreach Rep $LesReps {
if {[file exists "[RepertoireDuGenome]/$Rep/$Nom"]} { continue }
append Message " $Rep"
}
if {[regexp " " $Message]} { Espionne $Message }
}
}
proc AdnFictifPourCollection {{Liste ""} {Rep ""} {Zoom ""} {GetWhat ""} {Max ""}} {
global RepertoireDuGenome
global ADN TDN RAC
global DerniereBase LongueurADN
Wup "Si Zoom est negatif c'est la valeur qu'on prend pour une sequence"
Wup "Ca marche aussi si Rep est prottfa. Sauf pour ADN TDN et RAC (qui ne sert pas encore)"
Wup "Attention ca marche aussi pour un autre projet Gscope ... mais sans creer de fichiers"
if {$Liste==""} { set Liste [ListeDesPABs] }
if {$GetWhat==""} { set GetWhat "SaveAndGetFilename" }
if {$Rep==""} { set Rep nuctfa }
if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
set LongSeqConstante 999
if {$Zoom!="" && $Zoom<0} { set LongSeqConstante $Zoom; set Zoom 1 }
if {$Zoom==""} { set Zoom 1 }
set LongSeqConstante [expr -$LongSeqConstante]
#si elle est negative on l'oublie
set LongInconnu 300
if {[OuiOuNon "Do I keep frame 1 for all ORFs ?" 0]} {
set LongIntergene 99
} else {
set LongIntergene 100
}
set i [expr ($LongIntergene/3)*3]
set ADN [string repeat "n" $i]
set TDN [string repeat "n" $i]
set RAC [string repeat "n" $i]
set LesNouvellesBornesSansMutants {}
foreach PAB $Liste {
if {[EstUnPABMute $PAB]} {
# lappend LesNouvellesBornes "$PAB $Bornes"
continue
}
set FiNucTFA "$Rep/$PAB"
if {[file exists $FiNucTFA]} {
set SeqNuc [QueLaSequenceDuFichierTFA $FiNucTFA]
} else {
set SeqNuc [string repeat "n" $LongInconnu]
}
set Orient [Box $PAB orient]
if {$Orient=="F"} {
set SeqF $SeqNuc
} else {
set SeqF [NucToReverseAndComplementNuc $SeqNuc]
}
append ADN $SeqF
if {$LongSeqConstante<0} {
set LongSeq [string length $SeqNuc]
set LongSeq [expr round($LongSeq * $Zoom)]
} else {
set LongSeq $LongSeqConstante
}
if {[regexp "prottfa" $Rep]} { set LongSeq [expr $LongSeq*3] }
if {$Max!=""} { set LongSeq [Maxi $Max $LongSeq] }
set LongReste [expr (3-$LongSeq%3)%3]
set Fin [expr $i+$LongSeq]
set Debut [incr i]
Box $PAB debut $Debut
Box $PAB fin $Fin
set Bornes "$Debut $Fin $Orient"
lappend LesNouvellesBornesSansMutants "$PAB $Bornes"
set i $Fin
append ADN [string repeat "n" $LongReste]
incr i $LongReste
append ADN [string repeat "n" $LongIntergene]
incr i $LongIntergene
}
set TDN "n[NucToReverseNuc $ADN]"
set RAC "n[NucToReverseAndComplementNuc $ADN]"
set LesNouvellesBornes {}
foreach Ligne $LesNouvellesBornesSansMutants {
lappend LesNouvellesBornes $Ligne
scan $Ligne "%s" Nom
foreach Mutant [LesMutantsDe $Nom "Names"] {
regsub $Nom $Ligne $Mutant LigneMutant
lappend LesNouvellesBornes $LigneMutant
}
}
if {[string equal $GetWhat "GetBornesDesPABs"]} { return $LesNouvellesBornes }
set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
if { ! [OuiOuNon "Do I modify $FichierBornes ?"]} { return "" }
Garde $FichierBornes
set FBPab [SauveLesLignes $LesNouvellesBornes dans $FichierBornes]
return $FBPab
}
proc ChampsInteressantsDansTexteEMBL {Texte} {
global MemoCITembl
if { ! [info exists MemoCITembl(Ask)] || [set MemoCITembl(Ask)] } {
set Question "Can You help me to find GeneName and Definition in the known sequences\n\n"
append Question [string range $Texte 0 500]
if {[OuiOuNon $Question]} {
set MemoCITembl(GN_GNACID) [OuiOuNon "GN from GN (or AC (or ID)) ?"]
if {![set MemoCITembl(GN_GNACID)]} {
set MemoCITembl(GN_ACID) [OuiOuNon "GN from AC (or ID)) ?"]
} else {
set MemoCITembl(GN_ACID) 0
}
set MemoCITembl(DE_DE) [OuiOuNon "DE from DE ?"]
if {[OuiOuNon "Do I always apply these rules without asking."]} {
set MemoCITembl(Ask) 0
}
set MemoCITembl(No) [expr ! (\
[set MemoCITembl(GN_GNACID)] || \
[set MemoCITembl(GN_ACID)] || \
[set MemoCITembl(DE_DE)]) ]
} else {
set MemoCITembl(Ask) 0
set MemoCITembl(No) 1
}
}
if { ! [info exists MemoCITembl(No)] || [set MemoCITembl(No)]} { return "" }
set GN_GNACID [set MemoCITembl(GN_GNACID)]
set GN_ACID [set MemoCITembl(GN_ACID)]
set DE_DE [set MemoCITembl(DE_DE)]
set LesChamps {}
set LesChampsDE {}
foreach Ligne [split $Texte "\n"] {
if {[regexp "^SQ " $Ligne]} { break }
if { ! [regexp {^(ID|AC|DE|GN) } $Ligne Champ]} { continue }
regsub -all " " $Champ "" Champ
if {$Champ=="DE" && $DE_DE} { lappend LesChampsDE $Ligne }
set Champs($Champ) $Ligne
}
set GN ""
if {$GN_GNACID && [info exists Champs(GN)]} {
set GN [set Champs(GN)]
} elseif {$GN_GNACID && [info exists Champs(AC)]} {
regsub "^AC " [set Champs(AC)] "GN " GN
} elseif {$GN_GNACID && [info exists Champs(ID)]} {
regsub "^ID " [set Champs(ID)] "GN " GN
} elseif {$GN_ACID && [info exists Champs(AC)]} {
regsub "^AC " [set Champs(AC)] "GN " GN
} elseif {$GN_ACID && [info exists Champs(ID)]} {
regsub "^ID " [set Champs(ID)] "GN " GN
}
if {$GN!=""} { lappend LesChamps $GN }
if {$LesChampsDE!={}} {lappend LesChamps [join $LesChampsDE " // "]}
if {$LesChamps=={}} {
return {}
} else {
return [join $LesChamps "\n"]
}
}
proc BannisLePAB {Nom {Garde ""}} {
set LesExistants [glob -nocomplain "[RepertoireDuGenome]/*/$Nom"]
set LesDaEx {}
foreach Existant $LesExistants {
set Date [file mtime $Existant]
lappend LesDaEx [list $Date $Existant]
}
set LesDaEx [lsort -index 0 $LesDaEx]
set LesExistants {}
foreach DaEx $LesDaEx {
lappend LesExistants [lindex $DaEx 1]
}
set LesBannis [MorceauxChoisis $LesExistants "" "Select the files You want to delete"]
foreach Banni $LesBannis {
file delete -force $Banni
}
return $LesBannis
}
proc RetourneBisAccess Fichier {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s %s %s" A B L
if {$B=="sw:"} { set B $A }
Espionne "$B $A $L"
}
exit
}
proc LaTotalePourLesCDNAs {} {
global RepertoireDuGenome
if {! [file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} {
if {[OnTraiteDesAffymetrix]} {
CreeBornesDesCDNAs "Affymetrix"
} else {
CreeBornesDesCDNAs
}
}
ProtocoleEukaryotePourDNA
}
proc BetterStartCodon {} {
foreach Nom [ListeDesPABs] {
set Rapport [StartCodonReport $Nom "Rapport"]
if { ! [regexp "Wrong_Start_Codon" $Rapport]} { continue }
scan $Rapport "%s %s" W AsPos
regsub -all {[^0-9]} $AsPos "" Pos
if {$Pos<2} { continue }
set PosN [expr ($Pos-1)*3]
set OldDebut [Box $Nom debut]
set OldFin [Box $Nom fin]
set Orient [Box $Nom orient]
if {$Orient=="F"} {
Box $Nom debut [expr $OldDebut + $PosN]
} else {
Box $Nom fin [expr $OldFin - $PosN]
}
set OldSD [ShineDalgarno $Nom]
set SD [CreeLesFichiersDesShineDalgarnoDesPABs "" $Nom "RendreEtat"]
set nBases 0
set OldnBases 0
set Over [Overlap $Nom]
foreach Over [split $Over "/"] {
if { ! [regexp "I begin in" $Over]} { continue }
scan $Over "%s %d" Bidon OldnBases
set nBases [expr $OldnBases - $PosN]
break
}
Espionne [format "%s %4s Overlap de %3d a %3d SD: %7s %s" $Nom $AsPos $OldnBases $nBases $SD $OldSD]
}
exit
}
proc ATGAenOverlap {} {
set OneFour [Entre 4]
set n 0
set nATGA 0
set nGTGA 0
set nTTGA 0
set nOver4A 0
set nOver4G 0
set nOver4T 0
foreach Nom [ListeDesPABs] {
incr n
set FN "[RepertoireDuGenome]/nuctfa/$Nom"
if { ! [file exists $FN]} { continue }
set SeqNuc [QueLaSequenceDuFichierTFA $FN]
set Quatre [string range $SeqNuc 0 5]
if { ! [info exists Cumul($Quatre)]} { set Cumul($Quatre) 0 }
incr Cumul($Quatre)
if {[regexp -nocase "^ATGA" $SeqNuc] } {
incr nATGA
set Ov [Overlap $Nom]
if { ! [regexp "$OneFour bases. I begin" $Ov Match N] } { continue }
incr nOver4A
}
if {[regexp -nocase "^GTGA" $SeqNuc] } {
incr nGTGA
set Ov [Overlap $Nom]
if { ! [regexp "$OneFour bases. I begin" $Ov Match N] } { continue }
incr nOver4G
}
if {[regexp -nocase "^TTGA" $SeqNuc] } {
incr nTTGA
set Ov [Overlap $Nom]
if { ! [regexp "$OneFour bases. I begin" $Ov Match N] } { continue }
incr nOver4T
}
}
foreach {Q C} [array get Cumul] {
set U [string range $Q 0 2]
set D [string range $Q 3 5]
lappend LL [list $Q $C [AAduCodon $U][AAduCodon $D]]
}
EspionneL [lsort -index 1 -integer $LL]
return "$n $nATGA $nOver4A $nGTGA $nOver4G $nTTGA $nOver4T [file tail [RepertoireDuGenome]]"
}
proc RepartitionDesOverlaps {} {
global RepertoireDuGenome
foreach Nom [ListeDesPABs] {
set Ov [Overlap $Nom]
if { ! [regexp {([0-9]+) bases. I begin} $Ov Match N] } { continue }
if { ! [info exists Cumul($N)]} { set Cumul($N) 0 }
incr Cumul($N)
}
foreach N [NombresEntre 1 20] {
if { ! [info exists Cumul($N)]} { set C 0 } else { set C [set Cumul($N)] }
lappend Sortie "$N $C"
}
return $Sortie
}
proc FourBasesOverlap {} {
foreach f [glob "/genomics/*/fiches/overlap"] {
set Genome [file tail [file dirname [file dirname $f]]]
set L [llength [LesLignesDuFichier $f]]
if {$L==0} { continue }
set N [regexp -all " 4 bases. I begin" [ContenuDuFichier $f]]
set P [expr (100*$N)/$L]
lappend Sortie [format "%2d%s %s" $P "%" $Genome]
}
return $Sortie
}
proc GlimmersPerdus {{Quoi "LesPerdus"}} {
set n 0
foreach G [ListeDesGLIMMERs] {
if { ! [regexp "EstCharge" [CoGlimmer $G]]} { continue }
lappend LesPerdus $G
set Debut [Box $G debut]
set Fin [Box $G fin]
set Orient [Box $G orient]
set Long [expr abs($Fin-$Debut+1)]
if {$Long<300} {
lappend LesPerdusPetits "$G $Long"
} else {
lappend LesPerdusGrands "$G $Long"
}
}
return "[set $Quoi]\n[llength [set $Quoi]]"
}
proc CasimirCutted Nom {
global CasimirCutted
global RepertoireDuGenome
if {[info exists CasimirCutted($Nom)]} { return [set CasimirCutted($Nom)] }
if {[info exists CasimirCutted("EstCharge")]} { return 0 }
set CasimirCutted("EstCharge") 1
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/casimir_cutted"] {
scan $Ligne "%s" PAB
set CasimirCutted($PAB) $Ligne
lappend CasimirCutted(LaListeMerci) $PAB
}
return [CasimirCutted $Nom]
}
proc StopCommeGlimmer {{Qui "compte"}} {
foreach X {P G} Liste {ListeDesPABs ListeDesGLIMMERs} {
foreach PAB [$Liste] {
set Orient [Box $PAB orient]
set O $Orient
if {$Orient=="F"} {
set Debut [Box $PAB debut]
set Fin [Box $PAB fin]
set Long [expr $Fin-$Debut]
if {[info exists Fins($X,$O,$Fin)]} { FaireLire "[set Fins($X,$O,$Fin)] et $PAB meme fin" }
set Fins($X,$O,$Fin) $PAB
set Longs($X,$O,$Fin) $Long
} else {
set Debut [Box $PAB fin]
set Fin [Box $PAB debut]
set Long [expr $Debut-$Fin]
if {[info exists Fins($X,$O,$Fin)]} { FaireLire "[set Fins($X,$O,$Fin)] et $PAB meme fin" }
set Fins($X,$O,$Fin) $PAB
set Longs($X,$O,$Fin) $Long
}
}
}
lappend LesListesDispos LesMemesFins
lappend LesListesDispos LesMemesFinsPetits
lappend LesListesDispos LesMemesFinsSeules
lappend LesListesDispos LesMemesFinsSeulesPetits
lappend LesListesDispos LesMemesPile
lappend LesListesDispos LesMemesPilePetits
lappend LesListesDispos LesAutres
lappend LesListesDispos LesAutresPetits
lappend LesListesDispos LesGlimmersAuMax
lappend LesListesDispos LesGlimmersAuMaxPetits
lappend LesListesDispos LesGlimmersPasAuMax
lappend LesListesDispos LesGlimmersPasAuMaxPetits
lappend LesListesDispos LesCutted
lappend LesListesDispos LesCuttedPetits
foreach L $LesListesDispos {
set $L {}
}
foreach {XOFin PAB} [array get Fins] {
regsub -all "," $XOFin " " X_O_Fin
scan $X_O_Fin "%s %s %s" X O Fin
if {$X=="G"} { continue }
if {[info exists Fins(G,$O,$Fin)]} {
if {[set Longs($X,$O,$Fin)]==[set Longs(G,$O,$Fin)]} {
lappend LesMemesPile "$PAB [set Fins(G,$O,$Fin)]"
if {[set Longs($X,$O,$Fin)]<300} {
lappend LesMemesPilePetits "$PAB [set Longs($X,$O,$Fin)]"
}
} else {
lappend LesMemesFinsSeules "$PAB [set Fins(G,$O,$Fin)]"
if {[set Longs($X,$O,$Fin)]<300} {
lappend LesMemesFinsSeulesPetits "$PAB [set Longs($X,$O,$Fin)]"
}
scan [BornesDuGeneEtendu $PAB] "%s %d %d %s" Etendu DE FE OE
if {[CasimirCutted $PAB]!=0} {
if {[set Longs($X,$O,$Fin)]<300} {
lappend LesCuttedPetits "$PAB [set Longs($X,$O,$Fin)]"
}
lappend LesCutted "$PAB [set Fins(G,$O,$Fin)]"
}
set Glim [set Fins(G,$O,$Fin)]
set DG [Box $Glim debut]
set FG [Box $Glim fin]
set OG [Box $Glim orient]
if {"$DE $FE $OE"=="$DG $FG $OG"} {
lappend LesGlimmersAuMax [set Fins(G,$O,$Fin)]
if {[set Longs($X,$O,$Fin)]<300} {
lappend LesGlimmersAuMaxPetits "$PAB [set Longs($X,$O,$Fin)]"
}
} else {
lappend LesGlimmersPasAuMax [set Fins(G,$O,$Fin)]
if {[set Longs($X,$O,$Fin)]<300} {
lappend LesGlimmersPasAuMaxPetits "$PAB [set Longs($X,$O,$Fin)]"
}
}
}
lappend LesMemesFins "$PAB [set Fins(G,$O,$Fin)]"
if {[set Longs($X,$O,$Fin)]<300} {
lappend LesMemesFinsPetits "$PAB [set Longs($X,$O,$Fin)]"
}
} else {
lappend LesAutres "$PAB [set Longs($X,$O,$Fin)]"
if {[set Longs($X,$O,$Fin)]<300} {
lappend LesAutresPetits "$PAB [set Longs($X,$O,$Fin)]"
}
}
}
if {$Qui=="compte"} {
foreach L $LesListesDispos {
lappend Sortie [format "%5d %s" [llength [set $L]] $L]
}
return $Sortie
}
return [set $Qui]
}
proc PetitGscope {Ancien Nouveau {FichierOuListeDesAnciens ""} {Debut ""} {Fin ""}} {
set ListeDesAnciens $FichierOuListeDesAnciens
if {$FichierOuListeDesAnciens!="" && [FileExists $FichierOuListeDesAnciens]} {
set ListeDesAnciens [LesLignesDuFichier $FichierOuListeDesAnciens]
}
set Keep [OuiOuNon "Do I keep all existing files ?" 0]
set KeepUnusual [OuiOuNon "Do I keep all unusual files ?" 0]
set Premier ""
set Dernier ""
if {$Debut!=""} { set Premier [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $Debut] }
if {$Fin !=""} { set Dernier [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $Fin ] }
if { ! [regexp "/" $Ancien] } { set Ancien "/genomics/link/$Ancien" }
if { ! [regexp "/" $Nouveau]} { set Nouveau "/genomics/link/$Nouveau" }
if { ! [file exists $Ancien]} {
FaireLire "$Ancien doesn't exist"
exit
}
if { ! [file exists $Nouveau]} {
if { ! [OuiOuNon "Do I create $Nouveau"]} { exit }
file mkdir $Nouveau
}
foreach Fic [glob -nocomplain -type f "$Ancien/*"] {
if { ! $KeepUnusual} { Espionne "I skip $Fic" ; continue}
set Tail [file tail $Fic]
set NewFic "$Nouveau/$Tail"
if {$Keep && [file exists $NewFic]} { continue }
file copy -force $Fic $NewFic
}
foreach Lien [glob -nocomplain -type l "$Ancien/*"] {
if { ! $KeepUnusual} { Espionne "I do not create the link $Lien" ; continue }
set Tail [file tail $Lien]
set NewLien "$Nouveau/$Tail"
if {$Keep && [file exists $NewLien]} { continue }
set Cible [file readlink $Lien]
exec ln -sf $Cible $NewLien
}
foreach Rep [list "$Ancien/beton" "$Ancien/fiches" \
"$Ancien/trnadir" "$Ancien/glimmer" "$Ancien/codonw"\
"$Ancien/bilan_xhda" "$Ancien/xhda" ] {
if { ! [file exists $Rep]} { continue }
set Tail [file tail $Rep]
set NewRep "$Nouveau/$Tail"
set Skipp 0
Espionne $NewRep
while {[glob -nocomplain "$NewRep/*"]!={}} {
if {[OuiOuNon "$NewRep\n is not empty.\n Can I delete all files and copy the new version ?"]} {
file delete -force $NewRep
} else {
if {[OuiOuNon "Do I skipp $Rep ?"]} { set Skipp 1 ; break}
}
}
if {$Skipp} { continue }
Espionne "file copy -force $Rep $NewRep"
file copy -force $Rep $NewRep
foreach Lien [glob -nocomplain -type l "$Rep/*"] {
set Tail [file tail $Lien]
set NewLien "$NewRep/$Tail"
if {$Keep && [file exists $NewLien]} { continue }
set Cible [file readlink $Lien]
exec ln -sf $Cible $NewLien
}
set DejaVu($Rep) 1
}
set LesAutres {}
foreach Autre [glob -nocomplain -type d "$Ancien/*"] {
if {[info exists DejaVu($Rep)]} { continue }
lappend LesAutres $Autre
}
set LesGardes [MorceauxChoisis $LesAutres]
set LesPABs {}
foreach Rep $LesGardes {
Espionne $Rep
if {[info exists DejaVu($Rep)]} { continue }
set Tail [file tail $Rep]
set NewRep "$Nouveau/$Tail"
if { ! [file exists $NewRep]} { file mkdir $NewRep }
set OnAttend 1
if {$ListeDesAnciens!={}} { set OnAttend 0 }
foreach Fic [glob -nocomplain -type f "$Rep/*"] {
set Tail [file tail $Fic]
if {$ListeDesAnciens!={} && [lsearch $ListeDesAnciens $Tail]<0} { continue }
if {$Premier!="" && $OnAttend && $Tail < $Premier} { continue }
set OnAttend 0
if {$Dernier!="" && $Tail > $Dernier} { break }
set NewFic "$NewRep/$Tail"
if {$Keep && [file exists $NewFic]} { continue }
Espionne "file copy -force $Fic $NewFic"
file copy -force $Fic $NewFic
lappend LesPABs $Tail
}
foreach Lien [glob -nocomplain -type l "$Rep/*"] {
set Tail [file tail $Lien]
set NewLien "$NewRep/$Tail"
if {$Keep && [file exists $NewLien]} { continue }
set Cible [file readlink $Lien]
exec ln -sf $Cible $NewLien
}
}
set LesPABS [lsort -unique $LesPABs]
set LesBornes [AdnFictifPourCollection $LesPABS "prottfa" 1 "GetBornesDesPABs"]
set FichierBornes [SauveLesLignes $LesBornes dans "$Nouveau/fiches/bornesdespabs"]
FaireLire "Now You can \nsetgscoperr [file tail $Nouveau]\n and \n gscope"
return $FichierBornes
}
proc CreeBanqueBlastDuFichier {Fichier {NomDeLaBanque ""} {NomDeBapteme ""} {Format ""}} {
Wup "if necessary, converts Fichier to a tfa file,"
Wup " stores it in NomDeLaBanque,"
Wup " creates the blast database NomDeLaBanque.nhr .nin .nsq"
Wup " return the name of tfa file (=name of the blast database)"
JeMeSignale
if {$NomDeBapteme==""} { set NomDeBapteme [file tail $Fichier] }
if {$NomDeLaBanque==""} {
regsub {\.[^\.]*$} $Fichier "" NomDeLaBanque
}
set SeqDepart [ContenuDuFichier $Fichier]
if {($Format!="tfa" && ! [regexp "tfa" [FormatDeLaSequence $SeqDepart]]) || $NomDeBapteme!=""} {
set TFA [SequenceFormatTFA $SeqDepart $NomDeBapteme $Format]
} else {
set TFA $SeqDepart
}
set EcraseLeVieux 1
while {[file exists $NomDeLaBanque]} {
set Vieux [ContenuDuFichier $NomDeLaBanque]
if {$TFA!=$Vieux} {
set EcraseLeVieux 0
break
}
if {[OuiOuNon "$NomDeLaBanque\n already exists. Can I overwrite ?"]} { break }
}
if {$EcraseLeVieux} { Sauve $TFA dans $NomDeLaBanque }
exec formatdb -i $NomDeLaBanque -p F
return $NomDeLaBanque
}
proc RestrictionMap TexteOuFichierTFA {
if {[regexp "\n" $TexteOuFichierTFA]} {
set FichierTFA [Sauve $TexteOuFichierTFA dans "[TmpFile].tfa"]
} else {
if {[EstUnPAB $TexteOuFichierTFA]} {
set Nom $TexteOuFichierTFA
set FichierTFA [GscopeFile $Nom "nuctfa"]
} else {
set FichierTFA $TexteOuFichierTFA
}
}
set FichierMap "[TmpFile].map"
set ExecRemap "/gcg/EMBOSS/bin/remap"
if {[FileAbsent $ExecRemap]} { set ExecRemap "/bips/EMBOSS/bin/remap" }
set Retour [exec $ExecRemap -noreverse -outfile=$FichierMap -auto $FichierTFA]
return [AfficheFichier $FichierMap ""]
}
proc TDP {{Element ""}} {
set PS [PeptideSort "[RepertoireDuGenome]/prottfa/PGS047"]
Espionne $PS
Espionne [DecortiquePeptideSort $PS $Element]
exit
}
proc DecortiquePeptideSort {Texte {Element ""} {aT ""}} {
if {$aT!=""} { upvar $aT T }
set LesFloats {\
"Molecular weight" \
"Average Residue Weight" \
"Isoelectric point"}
set LesIntegers {\
"Residues" \
"Charged" \
"Extinction coefficient"}
foreach F $LesFloats {
regsub -all " " $F "" VF
set T($VF) 0.0
}
foreach I $LesIntegers {
regsub -all " " $I "" VI
set T($VI) 0
}
foreach Ligne [split $Texte "\n"] {
foreach F $LesFloats {
if {[regexp $F $Ligne]} {
regsub -all " " $F "" VF
set Valeur [FloatApres "$F =" dans $Ligne]
set T($VF) $Valeur
}
}
foreach I $LesIntegers {
if {[regexp $I $Ligne]} {
regsub -all " " $I "" VI
set Valeur [IntegerApres "$I =" dans $Ligne]
set T($VI) $Valeur
}
}
}
if {$Element==""} { return [array get T] }
if {[info exists T($Element)]} { return [set T($Element)] }
return "-99999"
}
proc AffichePeptideSort {Nom {Page ""} {ShowEnzymes ""}} {
if {[EstUnPAB $Nom]} {
set Texte [PeptideSort $Nom $ShowEnzymes]
} elseif {$Page!=""} {
set Texte [PeptideSort $Page $ShowEnzymes]
} elseif {$Nom!=""} {
set Texte [PeptideSort $Nom $ShowEnzymes]
} else {
return ""
}
if {$Texte==""} { return "" }
scan $Nom "%s" Titre
return [AfficheVariable $Texte "AvecRien" $Titre]
}
proc PeptideSort {NomOuFichierOuTexte {ShowEnzymes ""} } {
global RepertoireDuGenome
JeMeSignale
if {$ShowEnzymes=="ShowEnzymes"} { set EnzymeArg "\*" } else { set EnzymeArg "\#" }
if {[regexp "^>" $NomOuFichierOuTexte]} {
scan $NomOuFichierOuTexte "%s" Nom
regsub ">" $Nom "" Nom
set Seq [QueLaSequenceDuTexteTFA $NomOuFichierOuTexte]
} elseif {[regexp "/" $NomOuFichierOuTexte]} {
set Nom [file tail $NomOuFichierOuTexte]
set FichierTFA $NomOuFichierOuTexte
if { ! [file exists $FichierTFA]} { return "" }
set Seq [QueLaSequenceDuFichierTFA $FichierTFA]
} elseif {[EstUnPAB $NomOuFichierOuTexte]} {
set Nom $NomOuFichierOuTexte
set FichierTFA "$RepertoireDuGenome/prottfa/$Nom"
if { ! [file exists $FichierTFA]} { return "" }
set Seq [QueLaSequenceDuFichierTFA $FichierTFA]
} elseif {[regexp -nocase {^[a-z\*\-]+$} $NomOuFichierOuTexte]} {
set Seq $NomOuFichierOuTexte
set Nom "pepsort"
} else {
return ""
}
set Long [string length $Seq]
if {$Long<1} { return "" }
NousAllonsAuBoulot
set Racine [string tolower [TmpFile "${Nom}_"]]
set Queue [file tail $Racine]
set FichierTmpTfa "$Racine.tfa"
set FichierTmpPep "$Racine.pep"
set FichierPepSort "$Racine.pepsort"
# FromFasta $FichierTmpTfa $FichierTmpPep
Sauve [SequenceFormatTFA $Seq "$Queue" "brut"] dans "$FichierTmpTfa"
exec fromfasta -begin=1 -end=$Long -protein $FichierTmpTfa
if { ! [file exists $FichierTmpPep]} {
Espionne $FichierTmpTfa
# File delete -force $FichierTmpTfa
return "Error in PeptideSort : I couldn't convert $FichierTFA to GCG"
}
exec peptidesort -begin=1 -end=$Long -outputfile=$FichierPepSort -Enzymes=$EnzymeArg -default $FichierTmpPep
if { ! [file exists $FichierPepSort]} {
File delete -force $FichierTmpTfa
File delete -force $FichierTmpPep
return "Error in PeptideSort : gcg peptidesort didn't create $FichierPepSort"
}
set Resultat [ContenuDuFichier $FichierPepSort]
File delete -force $FichierTmpTfa
File delete -force $FichierTmpPep
File delete -force $FichierPepSort
OnRevientDuBoulot
regsub -all $Racine $Resultat $Nom Resultat
regsub -all $Queue $Resultat $Nom Resultat
return $Resultat
}
proc RepriseDuGscope {Ancien Nouveau} {
if { ! [regexp "/" $Ancien] } { set Ancien "/genomics/link/$Ancien" }
if { ! [regexp "/" $Nouveau]} { set Nouveau "/genomics/link/$Nouveau" }
if { ! [file exists $Ancien]} {
FaireLire "$Ancien doesn't exist\nPlease use the absolute path of your GscopeDir\nfor example:\n\
gscope RepriseDuGscope /genomics/link/OldTrululu /genomics/link/TrululuNew"
exit
}
if { ! [file exists $Nouveau]} {
if { ! [OuiOuNon "Do I create $Nouveau"]} { exit }
File mkdir $Nouveau
}
foreach Tail {beton fiches} {
set RepN "$Nouveau/$Tail"
if { ! [file exists $RepN]} { File mkdir $RepN }
}
foreach Fichier [glob "$Ancien/beton/*"] {
File copy -force $Fichier "$Nouveau/beton/"
}
FaireLire "Please choose the files to be copied from \n$Ancien/fiches\n to \n$Nouveau/fiches/"
set LesAnciensFiches [glob "$Ancien/fiches/*"]
set LesAnciensACopier [ChoixDesPresents $LesAnciensFiches]
foreach Fichier $LesAnciensACopier {
File copy -force $Fichier "$Nouveau/fiches"
}
FaireLire "Please select the directories to be copied"
set LesTails {nuctfa nucembl prottfa protembl infos blastp blastn tblastngenomes msf aliinout tfasdescopains}
set LesTails [ChoixDesPresents $LesTails]
foreach Tail $LesTails {
set RepA "$Ancien/$Tail"
if { ! [file exists $RepA]} { continue }
set RepN "$Nouveau/$Tail"
if { ! [file exists $RepN]} { File mkdir $RepN }
foreach Fichier [glob -nocomplain "$RepA/*"] {
File copy $Fichier "$RepN/"
}
}
FaireLire "Now You can \nsetgscope [file tail $Nouveau]\n and \n gscope"
exit
}
proc CodonsRares {Seq {SansZero ""} {args ""}} {
if {$args==""} {
# set LesRares {AGG AGA CGA CTA ATA CCC TAA TAG TGA}
set LesRares {AGG AGA CGA CTA ATA CCC}
} else {
set LesRares $args
}
if {$Seq=="LaListeMerci"} { return $LesRares }
if {$SansZero=="AvecBlanc"} { set AvecBlanc 1 } else { set AvecBlanc 0 }
if {$SansZero=="" || $SansZero=="SansZero"} {
set SansZero 1
} else {
set SansZero 0
}
set Seq [string toupper $Seq]
set L [string length $Seq]
set M [expr $L%3]
set Seq [string range $Seq 0 end-$M]
foreach Rare $LesRares {
set Compte($Rare) 0
}
foreach {a b c} [split $Seq ""] {
set Codon "$a$b$c"
if {[info exists Compte($Codon)]} { incr Compte($Codon)}
}
set LaSortie {}
foreach Rare $LesRares {
set N [set Compte($Rare)]
if {$SansZero && $N==0} { continue }
if {$AvecBlanc && $N==0} { lappend LaSortie " " ; continue }
lappend LaSortie "${N}_$Rare"
}
return [join $LaSortie " "]
}
proc AnchorsCount Nom {
global AnchorsCount
global RepertoireDuGenome
if {[info exists AnchorsCount($Nom)]} { return [set AnchorsCount($Nom)] }
if {[info exists AnchorsCount("EstCharge")]} { return [set AnchorsCount("EstCharge")] }
set FichierAnchorsCount "$RepertoireDuGenome/fiches/anchors_count"
while { ! [file exists $FichierAnchorsCount]} {
if { ! [OuiOuNon "Do I count, NOW, the anchors in each alignment ?"]} {
set AnchorsCount("EstCharge") -2
return [AnchorsCount $Nom]
} else {
set LesAnchors {}
foreach PAB [ListeDesPABs] {
set FichierMSF "$RepertoireDuGenome/msf/$PAB"
if { ! [file exists $FichierMSF]} { continue }
set Entete [string toupper [LesPremieresLignesDuFichier $FichierMSF 5]]
if { ! [regexp -nocase "ANCHORS" $Entete]} {
set N -3
} else {
set N [IntegerApres "ANCHORS" dans $Entete]
}
lappend LesAnchors "$PAB $N"
}
SauveLesLignes $LesAnchors dans $FichierAnchorsCount
}
}
set AnchorsCount("EstCharge") -1
foreach Ligne [LesLignesDuFichier $FichierAnchorsCount] {
scan $Ligne "%s %d" NomLu N
lappend AnchorsCount(LaListeMerci) $N
set AnchorsCount($NomLu) $N
}
return [AnchorsCount $Nom]
}
proc RetireNarcisseDesMSFs {} {
global RepertoireDuGenome
foreach Nom [ListeDesPABs] {
set FichierMSF "$RepertoireDuGenome/msf/$Nom"
set FichierMSF2 "$RepertoireDuGenome/msf2/$Nom"
if { ! [file exists $FichierMSF]} { continue }
set Nar [Narcisse $Nom]
if {$Nar==""} { continue }
set LeNouveau {}
foreach Ligne [LesLignesDuFichier $FichierMSF] {
if {[regexp -nocase "^$Nar " $Ligne] } { continue }
if {[regexp -nocase "Name: $Nar " $Ligne] } { continue }
lappend LeNouveau $Ligne
}
Espionne [SauveLesLignes $LeNouveau dans $FichierMSF2]
}
exit
}
proc GeneEtendu {Nom {Quoi ""}} {
global GeneEtendu
global RepertoireDuGenome
Wup "Quoi can be Old, Color, Signification"
if {$Quoi==""} { set Quoi "Ancien" }
if {[info exists GeneEtendu($Nom,$Quoi)]} { return [set GeneEtendu($Nom,$Quoi)] }
if {[info exists GeneEtendu("EstCharge",$Quoi)]} { return [set GeneEtendu("EstCharge",$Quoi)] }
set Fichier "$RepertoireDuGenome/fiches/genesetendus.diff"
if { ! [file exists $Fichier]} {
set GeneEtendu("EstCharge",Old) "NoFile"
set GeneEtendu("EstCharge",Color) "white"
set GeneEtendu("EstCharge",Signification) "NoFile"
set GeneEtendu(LaListeMerci,Old) "NoFile"
set GeneEtendu(LaListeMerci,Color) "white"
set GeneEtendu(LaListeMerci,Signification) "NoFile"
return [GeneEtendu $Nom $Quoi]
}
foreach {Old New} [LesLignesDuFichier $Fichier] {
scan $Old "%s" NomLu
regsub -nocase {[a-z]*} $NomLu [PreFixe] NomLu
set GeneEtendu($NomLu,Old) $Old
set GeneEtendu($NomLu,Color) "red"
set GeneEtendu($NomLu,Signification) "GeneWasExtended"
lappend GeneEtendu(LaListeMerci,Old) $Old
}
set GeneEtendu("EstCharge",Old) "NoExtension"
set GeneEtendu("EstCharge",Color) "green"
set GeneEtendu("EstCharge",Signification) "NoExtension"
set GeneEtendu(LaListeMerci,Color) [list "green" "red" "white"]
set GeneEtendu(LaListeMerci,Signification) [list "NoExtension" "GeneWasExtended" "NoFile"]
return [GeneEtendu $Nom $Quoi]
}
proc LesBornesDesGenesEtendus {{Fichier ""}} {
set LesDifferentes {}
foreach Nom [ListeDesPABs] {
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
set OldBornes "$Nom $Debut $Fin $Orient"
set Nouvelles [BornesDuGeneEtendu $Nom]
if {$Nouvelles!=$OldBornes} { lappend LesDifferentes $OldBornes $Nouvelles }
lappend LesBornes $Nouvelles
}
if {$Fichier==""} { return $LesBornes }
if {$Fichier=="AskForFile"} {
set Fichier [FichierPourSaveAs]
}
if {$Fichier==""} { return "" }
set FichierDiff "$Fichier.diff"
SauveLesLignes $LesDifferentes dans $FichierDiff
return [SauveLesLignes $LesBornes dans $Fichier]
}
proc BornesDuGeneEtendu Nom {
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
if {$Orient=="F"} {
set Gauche [expr $Debut - 300]
set SeqAvant [BoutADN $Gauche [expr $Debut-1] $Orient]
} else {
set Droite [expr $Fin + 300]
set SeqAvant [BoutADN [expr $Fin+1] $Droite $Orient]
}
set lSeqAvant [string length $SeqAvant]
set i [expr $lSeqAvant - 3]
set iDernierMet $lSeqAvant
while {$i>=0} {
set Codon [string range $SeqAvant $i [expr $i+2]]
if {[CodonStartPossible $Codon]} { set iDernierMet $i }
if {[CodonStopPossible $Codon]} { break }
incr i -3
}
set OldBornes "$Nom $Debut $Fin $Orient"
if {$Orient=="F"} {
set Bornes "$Nom [expr $Debut - ($lSeqAvant-$iDernierMet)] $Fin $Orient"
} else {
set Bornes "$Nom $Debut [expr $Fin + ($lSeqAvant-$iDernierMet)] $Orient"
}
return $Bornes
}
proc MergeLesPolylocalise {} {
global RepertoireDuGenome
set AutreFichier [ButineArborescence "All" "$RepertoireDuGenome/fiches"]
if {$AutreFichier==""} { return "" }
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/polylocalise"] {
scan $Ligne "%s" Nom
set MaPol($Nom) $Ligne
}
foreach Ligne [LesLignesDuFichier $AutreFichier] {
scan $Ligne "%s" Nom
Espionne $Ligne
if {[info exists MaPol($Nom)] && ! [regexp "NoBlastFile" [set MaPol($Nom)]]} {
lappend LeNouveau $MaPol($Nom)
} else {
lappend LeNouveau $Ligne
}
}
return [SauveLesLignes $LeNouveau dans "$RepertoireDuGenome/fiches/polylocalise.merge"]
}
proc RemoveMito {} {
global RepertoireDuGenome
foreach Nom [LesLignesDuFichier "[HomeRipp]/mito"] {
set EstMito($Nom) 1
}
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/cops_blastngenembl"] {
scan $Ligne "%s" Nom
if {[info exists EstMito($Nom)]} { continue }
lappend Sortie $Ligne
}
Espionne [SauveLesLignes $Sortie dans "$RepertoireDuGenome/fiches/cops_blastngenembl"]
exit
}
proc RechercheLesAccess Fichier {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s %s" Alias Access
set LL [LaSequenceDesBanques $Access $Access AccessOk "OnVeutNature"]
if {$LL=={}} {
Espionne "$Access ....................... not found"
} else {
set LigneAC [lindex $LL 1]
if { ! [regexp "^AC " $LigneAC]} {
FaireLire "Probleme avec $Alias $Access"
AfficheVariable [join $LL "\n"] "AvecFormateAvecBlasteAvecRetour"
set BonAccess "????????"
set TresBonAccess "?????????"
} else {
regsub -all ";" $LigneAC " " LigneAC
scan $LigneAC "%s %s" AC BonAccess
if {[LaSequenceDesBanques $BonAccess $BonAccess TresBonAccess]=={}} {
set TresBonAccess "Introuvable"
} else {
if {$BonAccess==$TresBonAccess} { set TresBonAccess "" }
lappend LesBons "$BonAccess $Alias"
}
}
Espionne [format "%-15s %-15s %-15s %-15s %-15s" $Alias $Access $AccessOk $BonAccess $TresBonAccess]
}
}
Espionne [SauveLesLignes $LesBons dans "access_alias.txt"]
exit
}
proc CompteLesStartCodonsOk {} {
global RepertoireDuGenome
set OldNom ""
set nOK 0
set DejaCompte 0
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/startcodon_summary.rr"] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
regsub "/" $Ligne "" Ligne
set Poch ""
scan $Ligne "%s %d %s %d %d %d %d %d %d %d %s" Nom iGGT MVL iMet oAv oAp F T a b Poch
if {[regexp {\+[1-9]} $Ligne]} { set oAp "+$oAp" }
if {[regexp {^ok[qsi]} $Poch]} {
set BonMet $iMet
InformeSansDemander $Nom "=MetRR: $MVL $BonMet"
Espionne $Ligne
Espionne " =MetRR: $MVL $BonMet"
}
if { ! $DejaCompte && $Nom==$OldNom && [regexp "^ok" $Poch]} {
incr nOK
set DejaCompte 1
}
if {$Nom!=$OldNom} { set DejaCompte 0 }
set OldNom $Nom
}
Espionne $nOK
exit
}
proc DecortiCohen {} {
global RepertoireDuGenome
set LesLignes [LesLignesDuFichier "[HomeRipp]/cohen.html"]
foreach Ligne $LesLignes {
if { ! [regexp "<TR><TD>" $Ligne]} { continue }
regsub -all "<TR>" $Ligne "" Ligne
regsub -all "<TD>" $Ligne "@" Ligne
ScanLaListe [split $Ligne "@"] X0 P D X1 X2 X3 C H A
regsub -all {<[^>]+>} $P "" PAB
if { ! [regexp "^PAB" $PAB]} { continue }
regsub -all {<[^>]+>} $C "" Commentaire
regsub "PAB" $PAB [PreFixe] Nom
Espionne $Nom
set LeTexte "Nom:$PAB"
lappend LeTexte "AuteurDate: $A $H"
lappend LeTexte "DeCo: $D"
lappend LeTexte "DeOO: [ExtraitInfo $Nom DE_Narcisse]"
set i 0
while {$Commentaire!=""} {
set Bout [string range $Commentaire 0 80]
set iBlanc [string last " " $Bout]
Espionne "$iBlanc $Commentaire"
if {$iBlanc==-1} { set iBlanc 80 }
set BonBout [string range $Commentaire 0 $iBlanc]
set Commentaire [string range $Commentaire [incr iBlanc] end]
lappend LeTexte "Comment_[incr i]: $BonBout"
}
SauveLesLignes $LeTexte dans "$RepertoireDuGenome/cohen/$Nom"
}
}
proc TFAsDeLaListe {Liste {Rep ""} {FichierACreer ""}} {
set LaSelection {}
if {$FichierACreer=="" && ($Rep=="GetText" || $Rep=="GetList")} {
set Rep $FichierACreer
set Rep ""
}
if {$Rep==""} {
set LaSelection $Liste
} else {
foreach El $Liste {
lappend LaSelection "$El $Rep"
}
}
set Selection [join $LaSelection "\n"]
return [CreeUnTFAs $Selection $FichierACreer]
}
proc CreeUnTFAs {Selection {FichierACreer ""}} {
global RepertoireDuGenome
Wup "Creates the TFAs file containing the sequences of the selected accesses"
if {$Selection == "" } { return }
if {[regexp "\n" $Selection]} {
set LaSelection [split $Selection "\n"]
} else {
set LaSelection $Selection
}
set SauveTFAs 1
set LesTFAS {}
foreach Ligne $LaSelection {
scan $Ligne "%s" Fichier
if {[regexp "/" $Fichier] && [file exists $Fichier]} {
set TFAouTFAs [ContenuDuFichier $Fichier]
set Format [FormatDeLaSequence $TFAouTFAs]
if {$Format=="tfa" || $Format=="tfas"} {
lappend LesTFAs $TFAouTFAs
}
continue
}
set Access ""
scan $Ligne "%s %s" BanqueId Access
if {[EstUnPAB $BanqueId]} {
set Nom $BanqueId
set Rep $Access
if {$Rep==""} { set Rep "nuctfa" }
set FicTFA [GscopeFile $Nom $Rep]
if {[FileExists $FicTFA]} {
set TFA [ContenuDuFichier $FicTFA]
lappend LesTFAs $TFA
}
continue
}
set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutNucEMBL"] "" "embl"]
lappend LesTFAs $TFA
}
if {$LesTFAs == {} } { return "" }
if {$FichierACreer=="GetText"} { return [join $LesTFAs "\n"] }
if {$FichierACreer=="GetList"} { return $LesTFAs }
set TFAs [join $LesTFAs "\n"]
if {$FichierACreer=="ShowIt"} {
return [AfficheVariable $TFAs "AvecFormate"]
}
if {$FichierACreer!=""} {
return [Sauve $TFAs dans $FichierACreer]
}
return $TFAs
}
proc CreeUnTFAsDesListesBidAccess {lBanqueId lAccess {FichierACreer ""}} {
global RepertoireDuGenome
Wup "Creates the TFAs file containing the sequences listed in lBanqueId lAccess"
set SauveTFAs 1
set LesTFAs {}
foreach BanqueId $lBanqueId Access $lAccess {
Espionne "Je cherche $BanqueId $Access"
set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutNucEMBL"] "" "embl"]
lappend LesTFAs $TFA
}
if {$LesTFAs == {} } { return "" }
set TFAs [join $LesTFAs "\n"]
if {$FichierACreer=="ShowIt"} {
return [AfficheVariable $TFAs "AvecFormate"]
}
if {$FichierACreer!=""} {
return [Sauve $TFAs dans $FichierACreer]
}
return $TFAs
}
proc QuiToucheCeChromosome {Chromo} {
set Fichier "~/$Chromo.liste"
return [SauveLesLignes [QuiTouche $Chromo] dans $Fichier]
}
proc QuiTouche {Chro {Contig ""}} {
set LesBons {}
foreach Nom [ListeDesPABs] {
set ML [MeilleureLocalisationSurChroContig $Nom]
scan $ML "%s %s" Ch Co
if {$Ch!=$Chro} { continue }
if {$Contig!="" && $Co!=$Contig} { continue }
lappend LesBons $Nom
}
return $LesBons
}
proc OrthographeCanonique Texte {
global OrthographeCanonique
global OrthographeCanoniqueInverse
set TEXTE [string trim [string toupper $Texte]]
regsub -all " " $TEXTE "_" TEXTE
if {[info exists OrthographeCanonique($TEXTE)]} { return [set OrthographeCanonique($TEXTE)] }
if { ! [info exists OrthographeCanonique]} {
set OrthographeCanonique(XENOPUS.) "Xenopus laevis"
set OrthographeCanonique(METHANOTHERMOBACTER_THERMAUTOTROPHICUS) "Methanobacterium thermoautotrophicum"
set OrthographeCanonique(M.THERMAUTOTROPHICUS) "Methanobacterium thermoautotrophicum"
# set OrthographeCanonique(DANIO_RERIO) "Brachydanio rerio"
# set OrthographeCanonique(DANI.RERIO) "Brachydanio rerio"
# set OrthographeCanonique(D.RERIO) "Brachydanio rerio"
if {[lsearch -exact [LesGenomesComplets] "Buchnera aphidicola"]<0} {
set OrthographeCanonique(BUCHNERA_SP) "Buchnera aphidicola"
set OrthographeCanonique(BUCHNERA_SP.) "Buchnera aphidicola"
set OrthographeCanonique(BUCH.SP) "Buchnera aphidicola"
set OrthographeCanonique(B.SP) "Buchnera aphidicola"
}
set OrthographeCanonique(UREAPLASMA_PARVUM) "Ureaplasma urealyticum"
set OrthographeCanonique(UREA.PARVU) "Ureaplasma urealyticum"
set OrthographeCanonique(U.PARVUM) "Ureaplasma urealyticum"
set OrthographeCanonique(RHIZOBIUM_MELILOTI) "Sinorhizobium meliloti"
set OrthographeCanonique(RHIZ.MELIL) "Sinorhizobium meliloti"
set OrthographeCanonique(R.MELILOTI) "Sinorhizobium meliloti"
set OrthographeCanonique(RHIZOBIUM_LOTI) "Mesorhizobium loti"
set OrthographeCanonique(RHIZ.LOTI) "Mesorhizobium loti"
set OrthographeCanonique(R.LOTI) "Mesorhizobium loti"
set OrthographeCanonique(SULFOLOBUS_TOKADAII) "Sulfolobus tokodaii"
set OrthographeCanonique(S.TOKADAII) "Sulfolobus tokodaii"
set OrthographeCanonique(SULF.TOKAD) "Sulfolobus tokodaii"
set OrthographeCanonique(SALMONELLA_TYPHI) "Salmonella enterica"
set OrthographeCanonique(S.TYPHI) "Salmonella enterica"
set OrthographeCanonique(THERMOPLASMA_VOLCANICUM) "Thermoplasma volcanium"
set OrthographeCanonique(T.VOLCANICUM) "Thermoplasma volcanium"
# set OrthographeCanonique(THERMUS_THERMOPHILUS) "Thermus aquaticus"
# set OrthographeCanonique(THER.THERM) "Thermus aquaticus"
# set OrthographeCanonique(T.THERMOPHILUS) "Thermus aquaticus"
foreach {BAD Good} [array get OrthographeCanonique] {
if { ! [regexp "_" $BAD]} { continue }
regsub "_" $BAD " " BAD
set Bad "[string index $BAD 0][string tolower [string range $BAD 1 end]]"
lappend OrthographeCanoniqueInverse($Good) $Bad
}
}
if {[info exists OrthographeCanonique($TEXTE)]} { return [set OrthographeCanonique($TEXTE)] }
return $Texte
}
proc LesGenomesCompletsBizarres {{Quoi ""}} {
if {$Quoi==""} {
set Quoi [ChoixParmi [list "Bizarres" "Nouveaux" "Inconnus"]]
if {$Quoi==""} { return {} }
}
set LesBizarres {}
set LesNouveaux {}
set LesInconnus {}
foreach O [LesGenomesComplets] {
set G [Glossaire $O Complet]
if {$G==$O} { continue }
set T [Tax $O "Name"]
if {$T==$O} {
lappend LesBizarres "New organism : $O"
lappend LesNouveaux $O
}
if {$T=="" || [regexp -nocase "Error" $T] } {
lappend LesBizarres "Wrong organism : $O"
lappend LesInconnus $O
}
}
if {$Quoi=="Bizarres"} { return $LesBizarres }
if {$Quoi=="Nouveaux"} { return $LesNouveaux }
if {$Quoi=="Inconnus"} { return $LesInconnus }
return $LesBizarres
}
proc SampledOrganism {Genre {Espece ""}} {
global SampledOrganism
global RepertoireDuGenome
if {$Espece==""} {
set O $Genre
} else {
set O "$Genre $Espece"
}
set Orga [Glossaire $O Complet]
if {$Orga==""} { set Orga $O }
if {[info exists SampledOrganism($Orga)]} { return [set SampledOrganism($Orga)] }
if {[info exists SampledOrganism ]} { return [set SampledOrganism("NotFound")] }
set Fichier "$RepertoireDuGenome/fiches/sampled_organism"
if {[file exists $Fichier]} {
set SampledOrganism(LaListeMerci) {}
foreach Ligne [LesLignesDuFichier $Fichier] {
set OrgaLu [string trim $Ligne]
lappend SampledOrganism(LaListeMerci) $OrgaLu
set SampledOrganism($OrgaLu) 1
}
set SampledOrganism("NotFound") 0
return [SampledOrganism $O]
}
set LaFamille {}
while {[OuiOuNon "Do You want to define 'Sampled Organisms' ?"]} {
if {[OuiOuNon "Do You want to copy or link an other 'SampledOrganism' file ?"]} {
set Autre [ButineArborescence "All" "$RepertoireDuGenome/.."]
if {$Autre==""} { continue }
if {[OuiOuNon "Do I link \n$Autre\n to \n$Fichier\n ?"]} {
exec ln -s $Autre $Fichier
} elseif {[OuiOuNon "Do I copy it ?"]} {
File copy $Autre $Fichier
}
return [SampledOrganism $O]
}
set LaFamille [ChoixDesPresents [FamiliarOrganism LaListeMerci]]
set Other ""
while {[OuiOuNon "Do You want to add other organisms to the sampled organisms list ?" 0]} {
set Other [Entre $Other]
set BonOther [Glossaire $Other Complet]
if {$BonOther==""} {
FaireLire "I don't know the organism $Other"
} else {
lappend LaFamille $BonOther
}
}
if {[OuiOuNon "[join $LaFamille "\n"]\n\nOK ?"]} { break }
}
if {$LaFamille=={}} {
if { ! [OuiOuNon "Do You want to save 'Sampled Organisms' as an empty list ?"]} {
set SampledOrganism("NotFound") 0
set SampledOrganism(LaListeMerci) {}
return [SampledOrganism $O]
}
}
SauveLesLignes $LaFamille dans $Fichier
return [SampledOrganism $O]
}
proc FamiliarTaxId {TaxId {Quoi ""}} {
global FamiliarTaxId
if {$Quoi==""} { set Quoi "Test" }
if {[info exists FamiliarTaxId($TaxId,$Quoi)]} { return [set FamiliarTaxId($TaxId,$Quoi)] }
if {[info exists FamiliarTaxId("TaxIdEstCharge")]} { return 0 }
set FamiliarTaxId("TaxIdEstCharge") 1
set FichierFOWTI "[RepertoireDuGenome]/fiches/familiar_organism_with_taxid"
while { ! [file exists $FichierFOWTI]} {
if { ! [OuiOuNon "Can I create the file\n$FichierFOWTI\nusing familiar_organism ?"]} {return 0}
TaxIdOfFamiliarOrganisms
}
foreach Ligne [LesLignesDuFichier $FichierFOWTI] {
scan $Ligne "%s %s %d" G E OX
set FamiliarTaxId($OX,All) $Ligne
set FamiliarTaxId($OX,Test) 1
lappend FamiliarTaxId(LaListeMerci,Test) $Ligne
}
return [FamiliarTaxId $TaxId $Quoi]
}
proc FamiliarOrganism {Genre {Espece ""}} {
global FamiliarOrganism
global RepertoireDuGenome
if {$Espece==""} {
set O $Genre
} else {
set O "$Genre $Espece"
}
if {[info exists FamiliarOrganism($O)]} { return [set FamiliarOrganism($O)] }
set Orga [Glossaire $O Complet]
if {$Orga==""} { set Orga $O }
if {[info exists FamiliarOrganism($Orga)]} { return [set FamiliarOrganism($Orga)] }
if {[info exists FamiliarOrganism ]} { return [set FamiliarOrganism("NotFound")] }
set Fichier "$RepertoireDuGenome/fiches/familiar_organism"
if {[file exists $Fichier]} {
Wup "We do it first for the most common used"
foreach G [LesGenomesComplets] {
set C [Glossaire $G Court]
set FamiliarOrganism($G) 0
set FamiliarOrganism($C) 0
}
set FamiliarOrganism(LaListeMerci) {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
if {[regexp {^ *\#} $Ligne]} { continue }
set OrgaLu [string trim $Ligne]
if {[Glossaire $OrgaLu Court]==""} {
if {[regexp -nocase {^ERROR} [set Bon [Tax $OrgaLu "Name"]]]} {
FaireLire "For familiar organism\nI don't know the organism \n$OrgaLu\n I'll skip it"
continue
}
set OrgaLu $Bon
}
lappend FamiliarOrganism(LaListeMerci) $OrgaLu
set FamiliarOrganism($OrgaLu) 1
set FamiliarOrganism([Glossaire $OrgaLu Court]) 1
}
set FamiliarOrganism("NotFound") 0
return [FamiliarOrganism $O]
}
set LaFamille {}
while {[OuiOuNon "Do You want to define 'Familiar Organisms' ?"]} {
if {[OuiOuNon "Do You want to copy or link an other 'FamiliarOrganism' file ?"]} {
set Autre [ButineArborescence "All" "$RepertoireDuGenome/.."]
if {$Autre==""} { continue }
if {[OuiOuNon "Do I link \n$Autre\n to \n$Fichier\n ?"]} {
exec ln -s $Autre $Fichier
} elseif {[OuiOuNon "Do I copy it ?"]} {
File copy $Autre $Fichier
}
return [FamiliarOrganism $O]
}
set LaFamille [ChoixDesPresents [LesGenomesComplets]]
set Other ""
while {[OuiOuNon "Do You want to add other organisms to the familiar organisms list ?" 0]} {
set Other [Entre $Other]
set BonOther [Glossaire $Other Complet]
if {$BonOther==""} {
FaireLire "I don't know the organism $Other"
} else {
lappend LaFamille $BonOther
}
}
if {[OuiOuNon "[join $LaFamille "\n"]\n\nOK ?"]} { break }
}
if {$LaFamille=={}} {
if { ! [OuiOuNon "Do You want to save 'Familiar Organisms' as an empty list ?"]} {
set FamiliarOrganism("NotFound") 0
set FamiliarOrganism(LaListeMerci) {}
return [FamiliarOrganism $O]
}
}
SauveLesLignes $LaFamille dans $Fichier
return [FamiliarOrganism $O]
}
proc TooCloseOrganism {Genre {Espece ""}} {
global TooCloseOrganism
global RepertoireDuGenome
if {$Espece==""} {
set O $Genre
} else {
set O "$Genre $Espece"
}
if {[info exists TooCloseOrganism($O)]} { return [set TooCloseOrganism($O)] }
set Orga [Glossaire $O Complet]
if {$Orga==""} { set Orga $O }
if {[info exists TooCloseOrganism($Orga)]} { return [set TooCloseOrganism($Orga)] }
if {[info exists TooCloseOrganism ]} { return [set TooCloseOrganism("NotFound")] }
set Fichier "$RepertoireDuGenome/fiches/tooclose_organism"
if {[file exists $Fichier]} {
Wup "We do it first for the most common used"
foreach G [LesGenomesComplets] {
set C [Glossaire $G Court]
set TooCloseOrganism($G) 0
set TooCloseOrganism($C) 0
}
set TooCloseOrganism(LaListeMerci) {}
foreach Ligne [LesLignesDuFichier $Fichier] {
set OrgaLu [string trim $Ligne]
lappend TooCloseOrganism(LaListeMerci) $OrgaLu
set TooCloseOrganism($OrgaLu) 1
set TooCloseOrganism([Glossaire $OrgaLu "Court"]) 1
Espionne [Glossaire $OrgaLu "Court"]
}
set TooCloseOrganism("NotFound") 0
return [TooCloseOrganism $O]
}
set LaFamille {}
while {[OuiOuNon "Do You want to define 'Too close organisms' ?"]} {
if {[OuiOuNon "Do You want to copy or link an other 'TooCloseOrganism' file ?"]} {
set Autre [ButineArborescence "All" "$RepertoireDuGenome/.."]
if {$Autre==""} { continue }
if {[OuiOuNon "Do I link \n$Autre\n to \n$Fichier\n ?"]} {
exec ln -s $Autre $Fichier
} elseif {[OuiOuNon "Do I copy it ?"]} {
File copy $Autre $Fichier
}
return [TooCloseOrganism $O]
}
set LaFamille [ChoixDesPresents [LesGenomesComplets]]
set Other ""
while {[OuiOuNon "Do You want to add other organisms to the too close organisms list ?" 0]} {
set Other [Entre $Other]
set BonOther [Glossaire $Other Complet]
if {$BonOther==""} {
FaireLire "I don't know the organism $Other"
} else {
lappend LaFamille $BonOther
}
}
if {[OuiOuNon "[join $LaFamille "\n"]\n\nOK ?"]} { break }
}
if {$LaFamille=={}} {
if { ! [OuiOuNon "Do You want to save 'Too Close Organisms' as an empty list ?"]} {
set TooCloseOrganism("NotFound") 0
set TooCloseOrganism(LaListeMerci) {}
return [TooCloseOrganism $O]
}
}
SauveLesLignes $LaFamille dans $Fichier
return [TooCloseOrganism $O]
}
proc CreeLesCDNAsDeRegine {{Fichier ""} {Repertoire ""}} {
global RepertoireDuGenome
if {$Fichier==""} {
FaireLire "Please browse for a file with 'clone length seq'"
set Fichier [ButineArborescence All "$RepertoireDuGenome"]
if {$Fichier==""} { return "" }
}
return $Fichier
if {$Repertoire==""} {
set Repertoire "$RepertoireDuGenome/cdna"
}
if { ! [file exists $Repertoire]} { File mkdir $Repertoire }
foreach Ligne [LesLignesDuFichier $Fichier] {
set Clone ""
set Long -1
set Seq ""
ScanLaListe [split $Ligne "\t"] Clone Long Seq
regsub -all -nocase {[^a-z0-9_]} $Clone "" Clone
if {$Seq=="NA" || [regexp "non ana" $Seq]} { set Seq "" }
Espionne "$Clone [string range $Seq 0 20] $Long [string length $Seq]"
if {[string length $Seq]==0} { continue }
set NomFichier "R$Clone.tfa"
set Entete "R $Clone"
set TFA [SequenceFormatTFA $Seq $Entete "nucbrut"]
Sauve $TFA dans "$Repertoire/$NomFichier"
}
exit
}
proc WithOverlapAffymetrix Nom {
return [llength [LesAffymetrixEnOverlap $Nom]]
}
proc LesAffymetrixDuOwner Owner {
foreach Nom [ListeDesPABs] {
if {[OwnerOfCDNA $Nom]!=$Owner} { continue }
Espionne "$Nom [LesAffymetrixEnOverlap $Nom]"
}
exit
}
proc CreeLesFichiersTFAsDesMeilleursCopainsDuBlastPourTous {RepBlast GrosFichierTFAs {Expect "1e-25"} {RepTFAs ""}} {
global RepertoireDuGenome
if { $RepTFAs=="" } { set RepTFAs "copains[file tail $RepBlast]" }
if { ! [regexp "/" $RepTFAs]} { set RepTFAs "$RepertoireDuGenome/$RepTFAs" }
if { ! [file exists $RepTFAs]} { File mkdir $RepTFAs }
foreach Nom [ListeDesPABs] {
Espionne "Je vais traiter $Nom"
set FichierTFAsACreer "$RepTFAs/$Nom"
if {[file exists $FichierTFAsACreer]} { continue }
set Texte [TexteTFAsDesMeilleursCopainsDuBlast $Nom $RepBlast $GrosFichierTFAs $Expect]
if {$Texte==""} { continue }
Espionne [Sauve $Texte dans "$FichierTFAsACreer"]
}
}
proc TexteTFAsDesMeilleursCopainsDuBlast {Nom RepBlast GrosFichierTFAs {Expect 0.001}} {
global RepertoireDuGenome
if { ! [regexp "/" $RepBlast]} { set RepBlast "$RepertoireDuGenome/$RepBlast" }
set FichierBlast "$RepBlast/$Nom"
if {$FichierBlast==""} { return "" }
set n [DecortiqueBlast $FichierBlast $Expect "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN]
if {$n==0} {
set n [DecortiqueBlast $FichierBlast 0.001 5 Query lBanqueId lAccess lDE lProfil lPN]
if {$n==0} { return "" }
}
Espionne $lBanqueId
set Texte [ExtraitLesSequencesDuTFAs $GrosFichierTFAs $lBanqueId]
return $Texte
}
proc ExtraitLesSequencesDuTFAs {FichierTFAs LesAccess} {
if {$LesAccess=={}} { return "" }
set E [open $FichierTFAs "r"]
set LesACCESS "turlututu"
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
set Beau($ACCESS) $Access
lappend LesACCESS $ACCESS
}
lappend LesACCESS "turlututu"
set ACCESSES [join $LesACCESS "="]
while {[gets $E Ligne]>=0} {
if { ! [regexp "^>" $Ligne]} {
if { [info exists Courant]} { lappend Sequences($Courant) $Ligne }
continue
}
if {[info exists Courant]} { unset Courant }
regsub ">" $Ligne "" LigneSansChevron
scan $LigneSansChevron "%s" AccessLu
set ACCESSLU [string toupper $AccessLu]
if { ! [regexp "=$ACCESSLU=" $ACCESSES]} { continue }
set Courant [set Beau($ACCESSLU)]
lappend Sequences($Courant) $Ligne
}
set Sortie {}
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
if {[info exists DejaVu($ACCESS)]} { continue }
set DejaVu($ACCESS) 1
if { ! [info exists Sequences($Access)]} { continue }
lappend Sortie [join [set Sequences($Access)] "\n"]
}
return [join $Sortie "\n"]
}
proc XtoN FichierTFA {
set E [open "$FichierTFA" "r"]
set S [open "$FichierTFA.new" "w"]
while {[gets $E Ligne]>=0} {
if { ! [regexp ">" $Ligne]} {
regsub -all -nocase "X" $Ligne "N" Ligne
}
puts $S $Ligne
}
exit
}
proc CreeBornesDesPABsAvecTFAs {{FichierTFAs ""} {KeepEntete ""} {CreateNarcisse ""} {ForceAccessFirst ""}} {
global RepertoireDuGenome
if {[OnTraiteDesNucleotides]} {
if { ! [file exists "$RepertoireDuGenome/nuctfa"]} { file mkdir "$RepertoireDuGenome/nuctfa" }
if { ! [file exists "$RepertoireDuGenome/nucembl"]} { file mkdir "$RepertoireDuGenome/nucembl" }
}
if {[OnTraiteDesProteines]} {
if { ! [file exists "$RepertoireDuGenome/prottfa"]} { file mkdir "$RepertoireDuGenome/prottfa" }
if { ! [file exists "$RepertoireDuGenome/protembl"]} { file mkdir "$RepertoireDuGenome/protembl" }
}
if {$FichierTFAs==""} {
if { ! [OuiOuNon "Could You browse a TFAs file with all sequences ? \n\
(I expect \n\
'>Access ...'\n\
or \n\
'>sp|Access|something definition (GN) ...')"]} {
return {}
}
set FichierTFAs [ButineArborescence "All" $RepertoireDuGenome]
if {$FichierTFAs==""} { return {} }
}
if {$KeepEntete==""} {
set KeepEntete [OuiOuNon "Do I keep the information following each '>'"]
} else {
set KeepEntete [string equal -nocase $KeepEntete "KeepEntete"]
}
if {$CreateNarcisse==""} {
set CreateNarcisse [OuiOuNon "Can I use the Access from each sequence to create Narcisse ?"]
} else {
set CreateNarcisse [string equal -nocase $CreateNarcisse "CreateNarcisse"]
}
if {$ForceAccessFirst==""} {
set ForceAccessFirst [OuiOuNon "Do I Force Access to be in position 1" 0]
} else {
set ForceAccessFirst [string equal -nocase $ForceAccessFirst "ForceAccessFirst"]
}
if {$ForceAccessFirst} { set ForceAccessFirst "ForceAccessFirst" } else { set ForceAccessFirst "" }
set AddNewSequences 0
set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
if {[file exists $FichierBornes]} {
if { ! [OuiOuNon "You want to add new sequences. Did You add them at the end of \n $FichierTFAs\n OK ?" 0]} {
return {}
}
set AddNewSequences 1
set LesExistants [lsort [ListeDesPABs]]
}
set Debut 101
set Fin 101
set Long 1000
set n 0
set LeBonChamp -1
foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "" $ForceAccessFirst] {
incr n
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set Fin [expr $Debut+$Long]
set Orient "F"
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
# SauveLesLignes $LesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs"
set Debut [expr $Fin + 33]
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
set FichierProtEMBL "$RepertoireDuGenome/protembl/$Nom"
set FichierProtTFA "$RepertoireDuGenome/prottfa/$Nom"
if {[OnTraiteDesProteines] && [file exists $FichierProtEMBL] && [file exists $FichierProtTFA] || \
[file exists $FichierNucEMBL] && [file exists $FichierNucTFA]} {
if {[OuiOuNonMemo "Do I keep the already existing sequences." 0]} {
Espionne "I skip $Nom"
continue
}
}
#Espionne "I'll create $Nom"
if {$AddNewSequences && [lsearch -exact $LesExistants $Nom]>=0} {
# set Debut [expr $Fin + 33]
continue
}
set BonAccess ""
set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
set NewWay [OuiOuNonMemo "I'll create sequences from a TFA file \n\
Are the header lines as follow\n\
>Access Definition\n\
>Access Homo sapiens Definition\n\
>sp|Access|Id Definition\n\
>sp|Access|Id Homo sapiens Definition\n\
"]
if {$NewWay} {
if {[OnTraiteDesProteines]} {
set FormatVer "tfa"
set SeqVer $TFA
set ProtEMBL [SequenceFormatEMBL $SeqVer $Nom "tfa"]
if {$FormatVer=="tfa"} {
set ProtTFA $SeqVer
regsub "^>" $ProtTFA ">$Nom " ProtTFA
} else {
set ProtEMBL [SequenceFormatEMBL $SeqVer $FormatVer]
set ProtTFA [SequenceFormatTFA $ProtEMBL "" "embl"]
}
Sauve $ProtEMBL dans $FichierProtEMBL
Sauve $ProtTFA dans $FichierProtTFA
if {[OuiOuNonMemo "Can I use the Access as Alias for each?"]} {
InformeSansDemander $Nom "Alias: $Access"
}
} else {
set FormatVer "tfa"
set SeqVer $TFA
set NucEMBL [SequenceFormatEMBL $SeqVer $Nom "tfa"]
if {$FormatVer=="tfa"} {
set NucTFA $SeqVer
regsub "^>" $NucTFA ">$Nom " NucTFA
} else {
set NucEMBL [SequenceFormatEMBL $SeqVer $FormatVer]
set NucTFA [SequenceFormatTFA $NucEMBL "" "embl"]
}
Sauve $NucEMBL dans $FichierNucEMBL
Sauve $NucTFA dans $FichierNucTFA
if {[OuiOuNonMemo "Can I use the Access as Alias for each?"]} {
InformeSansDemander $Nom "Alias: $Access"
}
}
}
if { ! $NewWay} {
set Seq [QueLaSequenceDuTexteTFA $TFA]
set Ent [EnteteDuTexteTFA $TFA]
regsub {>+} $Ent "" Ent
scan $Ent "%s" Access
if {[regexp {\|} $Access]} {
if {$LeBonChamp < 0} {
set LesChamps [split $Access "|"]
FaireLire "Please help me to choose the correct access in $Access"
set LeBonChamp [ChoixParmiJoli [NombresEntre 0 [expr [llength $LesChamps]-1]] {} $LesChamps]
if {$LeBonChamp==""} { set LeBonChamp 999 }
}
set BonAccess [lindex $LesChamps $LeBonChamp]
} else {
set BonAccess $Access
}
set Descr [string trim [StringSuivant " " dans $Ent]]
if {$Descr==""} { set Descr $Ent }
if {[regexp -nocase {\([a-z0-9_]+\)} $Ent GN]} {
set GN [string range $GN 1 end-1]
} else {
set GN ""
}
set LongSeq [string length $Seq]
set Seq [SequenceFormatBrut $Seq]
if {$BonAccess!=""} {
AppendAuFichier "$RepertoireDuGenome/fiches/narcisse" "$Nom $BonAccess"
}
if {([OnTraiteDesNucleotides] || [OnTraiteDesCDS]) && \
(! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA])} {
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $Nom created by Gscope from a tfas file "
lappend LesLignesEMBL "AC $Nom;"
if {$GN!=""} {
lappend LesLignesEMBL "GN $GN"
InformeSansDemander $Nom "ValiGN: $GN"
}
set Sep ":"
foreach Wrap [WrapLeTexte $Descr 50] {
lappend LesLignesEMBL "CC Original description$Sep $Wrap"
set Sep "+"
}
lappend LesLignesEMBL "SQ SEQUENCE $LongSeq bases;"
lappend LesLignesEMBL $Seq
if {$KeepEntete} {
set Entete "$Nom $Ent"
} else {
set Entete "$Nom $Descr"
}
scan $Entete "%s %s" A B
if {$A==$B} { regsub "$A +" $Entete "" Entete }
set NucEMBL [join $LesLignesEMBL "\n"]
Sauve $NucEMBL dans $FichierNucEMBL
set NucTFA [SequenceFormatTFA $NucEMBL $Entete "embl"]
Sauve $NucTFA dans $FichierNucTFA
}
if {[OnTraiteDesProteines] && \
(! [file exists $FichierProtEMBL] || ! [file exists $FichierProtTFA])} {
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $Nom created by Gscope from a tfas file "
lappend LesLignesEMBL "AC $Nom;"
if {$GN!=""} {
lappend LesLignesEMBL "GN $GN"
InformeSansDemander $Nom "ValiGN: $GN"
}
set Sep ":"
foreach Wrap [WrapLeTexte $Descr 50] {
lappend LesLignesEMBL "CC Original description$Sep $Wrap"
set Sep "+"
}
if {[OnTraiteDesCDS]} {
if { ! [file exists $FichierNucTFA]} { continue }
set Seq [SeqNucToSeqPro [QueLaSequenceDuFichierTFA $FichierNucTFA]]
set LongSeq [string length $Seq]
}
lappend LesLignesEMBL "SQ SEQUENCE $LongSeq AA;"
lappend LesLignesEMBL $Seq
if {$KeepEntete} {
set Entete "$Nom $Ent"
} else {
set Entete "$Nom $Descr"
}
set ProtEMBL [join $LesLignesEMBL "\n"]
set ProtTFA [SequenceFormatTFA $ProtEMBL "$Entete" "embl"]
Sauve $ProtTFA dans $FichierProtTFA
Sauve $ProtEMBL dans "$RepertoireDuGenome/protembl/$Nom"
}
}
}
SauveLesLignes $LesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs"
}
proc VoirADNduContig {ChroContig Selection} {
set SansAffichage ""
set CarNature(Prom) "P"
set CarNature(Init) "I"
set CarNature(Intr) "X"
set CarNature(Sngl) "S"
set CarNature(Term) "T"
set CarNature(PlyA) "A"
set CarNature(InGN) "."
set CarNature(OuGN) " "
set LesBornes {}
foreach Ligne [split $Selection "\n"] {
if { ! [regexp {^ *[0-9]+\.[0-9]+ } $Ligne]} { continue }
scan $Ligne "%s %s %s %d %d" Num Nature Sens D F
if {$Sens=="-"} {
set W $D
set D $F
set F $W
}
lappend LesBornes "$D $F $Sens"
set C " "
if {[info exists CarNature($Nature)]} { set C [set CarNature($Nature)] }
set CarNature($D) $C
set Orientation($D) $Sens
}
if {$LesBornes=={}} { return "" }
set Seq "n[QueLaSequenceDuTFA [ContigEnStock $ChroContig "FileNamePlease"]]"
Espionne "$ChroContig $Seq"
if {$Seq==""} { return "" }
set BornesDebut [lindex $LesBornes 0]
scan $BornesDebut "%s" Debut
set BornesFin [lindex $LesBornes end]
scan $BornesFin "%s %s" Bidon Fin
set LongN [expr $Fin-$Debut+1]
set DebutEtendu [expr $Debut-99]
set FinEtendu [expr $Fin +99]
while { $DebutEtendu < 1 } { incr DebutEtendu 3}
while { $FinEtendu >= [string length $Seq] } { incr FinEtendu -3}
set adn [string range $Seq $DebutEtendu $FinEtendu]
set tdn [NucToComplementNuc $adn]
set Orient "F"
set NaturePlus ""
set NatureMinus ""
set pep(0) ""
set pep(1) ""
set pep(2) ""
set pep(3) ""
set pep(4) ""
set pep(5) ""
set Precision 25
set Loc $DebutEtendu
set Regle [string repeat " " [expr $Precision - $Loc%$Precision]]
set iBornes 0
set Bornes [lindex $LesBornes $iBornes]
scan $Bornes "%d %d %s" D F Sens
for {set i 0} { $i < [string length $adn] } {incr i } {
append pep([expr $i%3]) "[AAduCodon [string range $adn $i [expr $i+2]]] "
append pep([expr $i%3+3]) "[AAduCodon [ReverseString [string range $tdn $i [expr $i+2]]]] "
set Car " "
if {$D <= $Loc && $Loc <= $F} {
set Car [set CarNature($D)]
set Sens [set Orientation($D)]
if {$Car==" "} { set Car [set CarNature(InGN)] }
}
if {$Sens=="+"} {
append NaturePlus $Car
append NatureMinus " "
} else {
append NaturePlus " "
append NatureMinus $Car
}
if {$Loc==$F} {
incr iBornes
set Bornes [lindex $LesBornes $iBornes]
scan $Bornes "%d %d %s" D F Sens
}
if {[expr $Loc-($Loc/$Precision)*$Precision]==0} {
set Gradu [string range "$Loc[string repeat " " $Precision]" 0 [expr $Precision - 1]]
append Regle $Gradu
}
incr Loc
}
set FrameP0 " $pep(2)"
set FrameP1 " $pep(1)"
set FrameP2 "$pep(0)"
set FrameM0 " $pep(3)"
set FrameM1 " $pep(4)"
set FrameM2 " $pep(5)"
set Texte "$FrameP0\n$FrameP1\n$FrameP2\n\
$NaturePlus\n$adn\n$Regle\n$tdn\n$NatureMinus\n\
$FrameM0\n$FrameM1\n$FrameM2"
set i -1
foreach Ligne [split $Texte "\n"] {
set LaLigne([incr i]) $Ligne
lappend LesIemes $i
}
set Largeur 1000
set D 0
set F [expr $D+$Largeur-1]
set LeHachis {}
while {$D<$FinEtendu} {
foreach i $LesIemes {
lappend LeHachis [string range [set LaLigne($i)] $D $F]
}
lappend LeHachis "\n"
incr D $Largeur
incr F $Largeur
}
set Texte [join $LeHachis "\n"]
if {$SansAffichage!=""} { return $Texte }
return [AfficheVariable $Texte "GrandeLargeur" $ChroContig]
}
proc ReAlignePourTous {} {
global RepertoireDuGenome
global MyDbClustal
while { ! [info exists MyDbClustal]} {
set MyDbClustal "integral"
if { ! [OuiOuNon "Do You want to use $MyDbClustal"]} {
set MyDbClustal [Entre $MyDbClustal]
}
if {$MyDbClustal==""} { unset MyDbClustal }
}
set RepSortie ""
while {$RepSortie==""} {
set RepSortie "$RepertoireDuGenome/msf2"
if { ! [OuiOuNon "Do You want to store the new alignments in\n$RepSortie"]} {
set RepSortie [Entre "$RepertoireDuGenome/"]
}
}
if { ! [file exists $RepSortie]} { File mkdir $RepSortie }
set Keep 1
if {[llength [glob -nocomplain "$RepSortie/*"]]>0} {
set Keep [OuiOuNon "Do I keep existing files in \n$RepSortie ?"]
}
foreach Nom [ListeDesPABs] {
if {[PasTouche $Nom]} { continue }
set FichierMSF "$RepSortie/$Nom"
if {$Keep && [file exists $FichierMSF]} { continue }
set Status [ReAligne $Nom $FichierMSF]
Espionne "$Nom $Status"
FinPasTouche $Nom
}
}
proc ReAligne {Nom {FichierMSF ""}} {
global RepertoireDuGenome
global MyDbClustal
if {$FichierMSF=="" || $FichierMSF=="RetourneTexteMSF"} {
set FichierMSF [TmpFile].msf
set RetourneTexte 1
} else {
set RetourneTexte 0
}
while { ! [info exists MyDbClustal]} {
set MyDbClustal "integral"
if { ! [OuiOuNon "Do You want to use $MyDbClustal"]} {
set MyDbClustal [Entre $MyDbClustal]
}
if {$MyDbClustal==""} { unset MyDbClustal }
}
set MSFOrigine "$RepertoireDuGenome/msf/$Nom"
if { ! [file exists $MSFOrigine]} { return "" }
set n [DecortiqueUnMSF $MSFOrigine LesNomsDesSeqs Seqs]
if {$n<2} { return "" }
set LesTFAs {}
foreach NomSeq $LesNomsDesSeqs {
set Seq [set Seqs($NomSeq)]
regsub -all -nocase {[^a-z]} $Seq "" Seq
set TFA [SequenceFormatTFA $Seq $NomSeq "protbrut"]
lappend LesTFAs $TFA
}
set TFAs [join $LesTFAs "\n"]
set Status [DbClustal $Nom $FichierMSF $TFAs "AvecTexteTFAs"]
if {$RetourneTexte} {
if {[file exists $FichierMSF]} {
return [ContenuDuFichier $FichierMSF]
} else {
return ""
}
} else {
return $Status
}
}
proc Maigrir {{Quoi "blastp"} {Combien ""} {NomVoulu ""} {NewRep ""}} {
if {$Combien==""} { set Combien 13 }
set Rep "[RepertoireDuGenome]/$Quoi"
if {$NewRep==""} { set NewRep $Quoi }
if { ! [regexp "/" $NewRep]} { set NewRep "[RepertoireDuGenome]/$NewRep" }
if { ! [OuiOuNon "I will reduce the blast segment alignments to $Combien\n\
from $Rep \nto $NewRep\n OK ?" 0]} { return 0 }
if {$NomVoulu==""} {
set Liste [ListeDesPABs]
} else {
set Liste [list $NomVoulu]
}
foreach Nom $Liste {
set FichierAvant "$Rep/$Nom"
if { ! [file exists $FichierAvant]} { continue }
set FichierApres "$NewRep/$Nom"
if {[file exists $FichierApres]} { continue }
set ListeDesLignes [LesLignesDuFichier $FichierAvant]
set LongAvant [llength $ListeDesLignes]
scan [join [lrange $ListeDesLignes 0 3] " "] "%s" PremierMot
set PremierMot [string toupper $PremierMot]
# set PourBlastP [string equal -nocase $PremierMot "BLASTP"]
# set PourBallast [string equal -nocase $PremierMot "Ballast"]
# set PourTBlastX [string equal -nocase $PremierMot "TBLASTX"]
# set PourBlastN [string equal -nocase $PremierMot "BLASTN"]
# set PourTBlastN [string equal -nocase $PremierMot "TBLASTN"]
set PourBlastP [expr ! [string compare $PremierMot "BLASTP"]]
set PourBlastX [expr ! [string compare $PremierMot "BLASTX"]]
set PourTBlastX [expr ! [string compare $PremierMot "TBLASTX"]]
set PourBlastN [expr ! [string compare $PremierMot "BLASTN"]]
set PourTBlastN [expr ! [string compare $PremierMot "TBLASTN"]]
set PourBallast [expr ! [string compare $PremierMot "BALLAST"]]
if { ! [expr $PourBlastP+$PourBlastX+$PourBallast+$PourTBlastX+$PourBlastN+$PourTBlastN] == 1} {
Warne "$Fichier is not a blast file. I skipp it."
continue
}
set Encore $Combien
set LeNouveau {}
set LongApres 0
foreach Ligne $ListeDesLignes {
if {[regexp "^>" $Ligne]} {
if { ! [incr Encore -1]} { break }
}
incr LongApres
lappend LeNouveau $Ligne
}
SauveLesLignes $LeNouveau dans $FichierApres
Espionne "$Nom a maigri de $LongAvant a $LongApres"
}
return 1
}
proc AfficheGenscanDuContig Selection {
Wup "Shows Genscan output for all contig of selection"
if {$Selection==""} { return "" }
set F ""
foreach Ligne [split $Selection "\n"] {
scan $Ligne "%s" ChroContig
set FichierGSC [GenScanEnStock $ChroContig "FileNamePlease"]
if {$FichierGSC==""} { continue }
set F [AfficheFichier $FichierGSC "AvecRien"]
set B [BoutonneLaFenetre $F "See DNA of sel.\nBlastP sel. prot" ""]
$B configure -background "green"
bind $B <1> "VoirADNduContig $ChroContig \[selection get\]"
bind $B <Shift-1> "Blaste P \[selection get\]"
}
return $F
}
proc AffymetrixAssocie {} {
global AffymetrixAssocie
global RepertoireDuGenome
if {[info exists AffymetrixAssocie]} {
if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
return $AffymetrixAssocie
}
set FichierAA "$RepertoireDuGenome/fiches/affymetrixassocie"
if {[file exists $FichierAA]} {
scan [ContenuDuFichier $FichierAA] "%s" AffymetrixAssocie
if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
return $AffymetrixAssocie
}
set D ""
while {$D==""} {
if { ! [OuiOuNon "Do You want to correlate with an associated Affymetrix Gscope ?" 0]} {
set D "NoAssociatedAffymetrix"
break
}
FaireLire "I need to know the associated Affymetrix directory.\nPlease browse for it."
set D [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
if {$D==""} {
set D [Entre "NoAssociatedAffymetrix"]
}
}
set AffymetrixAssocie [file tail $D]
Sauve $AffymetrixAssocie dans $FichierAA
if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
return $AffymetrixAssocie
}
proc JumeauRepresentatif Nom {
global JumeauRepresentatif
if {[info exists JumeauRepresentatif($Nom)]} { return [set JumeauRepresentatif($Nom)] }
if {[info exists JumeauRepresentatif("EstCharge")]} { return "" }
set FichierDesJumeaux "[RepertoireDuGenome]/fiches/jumeaux"
if { ! [file exists $FichierDesJumeaux]} {
set LesFichiersJumeaux [glob -nocomplain "[RepertoireDuGenome]/fiches/jumeaux*"]
if {[llength $LesFichiersJumeaux]>0} {
set LesPossibles $LesFichiersJumeaux
lappend LesPossibles "Run a new Jumeaux"
set FichierDesJumeaux [ChoixParmi $LesPossibles]
if {$FichierDesJumeaux=="Run a new Jumeaux"} { set FichierDesJumeaux "" }
}
}
if { $FichierDesJumeaux=={} || ! [file exists $FichierDesJumeaux]} {
if {[OuiOuNon "Do You want to run Jumeaux ?"]} {
set FichierDesJumeaux [Jumeaux "Ask"]
}
}
foreach Ligne [LesLignesDuFichier $FichierDesJumeaux] {
set LesJumeaux [split $Ligne " "]
set JR [lindex $LesJumeaux 0]
lappend JumeauRepresentatif(LaListeMerci) $JR
foreach J [lrange $LesJumeaux 0 end] {
set JumeauRepresentatif($J) $JR
}
}
set JumeauRepresentatif("EstCharge") 1
return [JumeauRepresentatif $Nom]
}
proc CleanSpace {} {
global RepertoireDuGenome
foreach F [glob "$RepertoireDuGenome/cdna/*"] {
regsub -all "'" $F "_" D
regsub -all " " $D "" D
regsub "/cdna/" $D "/newcdna/" D
file copy $F $D
}
}
proc CreeBornesDesPABsLoc {} {
global RepertoireDuGenome
set FichTrD "$RepertoireDuGenome/fiches/localisationchrocontig.trid.best"
set InterChros 1200
set InterContigs 900
set InterIlots 300
set MaxiInterIlots 30
foreach Loc [LesLignesDuFichier $FichTrD] {
scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
set ChroContig "$Chro$Contig"
if { ! [info exists DejaVu($ChroContig)]} lappend LesChroContig $ChroContig
lappend LesLocsDu($ChroContig) $Loc
if { ! [info exists AlphaDu($ChroContig)]} {
set OmegaDu($ChroContig) $Fin
} else {
set AlphaDu($ChroContig) [Mini $Debut [set AlphaDu($ChroContig)]]
set OmegaDu($ChroContig) [Maxi $Fin [set OmegaDu($ChroContig)]]
}
}
set Depart 0
set OldOmega 0
foreach ChroContig $LesChroContig {
set LesLocs {}
set LesDebuts {}
set LesFins {}
foreach Loc [set LesLocsDu($ChroContig)] {
scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
lappend LesDebuts $DebutCd
lappend LesFins $FinCd
lappend LesLocs $Loc
}
set Alpha [set AlphaDu($ChroContig)]
set Omega [set OmegaDu($ChroContig)]
Espionne [expr $Omega - $Alpha]
foreach Loc $LesLocs {
scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
set D [expr $Depart+($Debut-$Alpha)]
set F [expr $D+$Fin-$Debut]
if {$Sens=="+"} { set O "F" } else { set O "R" }
Espionne "$Nom $D $F $O"
lappend LesBornes "$Nom $D $F $O"
}
set OldOmega $Omega
set RajoutArrondi [expr (($Inter+$Omega-$Alpha+3)/3)*3]
Espionne "$Depart $OldOmega $Alpha $Omega $RajoutArrondi"
incr Depart $RajoutArrondi
set LesLocs {}
set LesDebuts {}
set LesFins {}
}
SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs_loc"
}
proc OldCreeBornesDesPABsLoc {} {
global RepertoireDuGenome
set FichTrD "$RepertoireDuGenome/fiches/localisationchrocontig.trid.best"
set FichTrF "$RepertoireDuGenome/fiches/localisationchrocontig.trif.best"
set LesCd [LesLignesDuFichier $FichTrD]
set LesAf [LesLignesDuFichier $FichTrF]
set InterChros 1200
set InterContigs 900
set InterIlots 300
set MaxiInterIlots 30
set OldChro "ChroBidon"
set OldContig "ContigBidon"
set Depart 0
set OldOmega 0
set LesLocs {}
set LesDebuts {}
set LesFins {}
foreach Cd $LesCd Af $LesAf {
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
lappend LesLocs $Cd
lappend LesDebuts $DebutCd
lappend LesFins $FinCd
if {$NomCd!=$NomAf} {
if {[info exists OnAttend($NomCd,D)]} { unset OnAttend($NomCd,D) } else { set OnAttend($NomCd,F) 1 }
if {[info exists OnAttend($NomAf,F)]} { unset OnAttend($NomAf,F) } else { set OnAttend($NomAf,D) 1 }
}
if {[info exists OnAttend]} {Espionne [array names OnAttend]}
if {[info exists OnAttend] && [array names OnAttend]!={}} { continue }
set Alpha [MiniDeLaListe $LesDebuts]
set Omega [MaxiDeLaListe $LesFins]
Espionne [expr $Omega - $Alpha]
set Inter 0
if {[expr ($Alpha-$OldOmega) > $MaxiInterIlots] } { set Inter $InterIlots }
if {$OldContig!=$ContigCd} { set Inter $InterContigs }
if {$OldChro!=$ChroCd} { set Inter $InterChros }
foreach Loc $LesLocs {
scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
set D [expr $Depart+$Inter+($Debut-$Alpha)]
set F [expr $D+$Fin-$Debut]
if {$Sens=="+"} { set O "F" } else { set O "R" }
Espionne "$Nom $D $F $O"
lappend LesBornes "$Nom $D $F $O"
}
set OldOmega $Omega
set RajoutArrondi [expr (($Inter+$Omega-$Alpha+3)/3)*3]
Espionne "$Depart $OldOmega $Alpha $Omega $RajoutArrondi"
incr Depart $RajoutArrondi
set LesLocs {}
set LesDebuts {}
set LesFins {}
}
SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs_loc"
}
proc MeilleureLocalisationSurChroContig Nom {
set LesLocs [LesLocalisationsSurChroContig $Nom]
if {$LesLocs=={}} { return "Chro0 Contig00 -1 -1 -" }
set Meilleure [lindex $LesLocs 0]
if {$Meilleure=="No value"} { return "Chro0 Contig00 0 0 +" }
return $Meilleure
}
proc LesCDNAsEnOverlap {Nom {BestOnly ""}} {
global LesCDNAsEnOverlap
global RepertoireDuGenome
Wup "Attention si on commence en BestOnly il le reste durant tout le run et vice versa"
set BestOnly [regexp -nocase "BestOnly" $BestOnly]
if {$BestOnly} { set Best ".best" } else { set Best "" }
if {[info exists LesCDNAsEnOverlap($Nom)]} {
return [set LesCDNAsEnOverlap($Nom)]
}
if {[info exists LesCDNAsEnOverlap("EstCharge")]} {
return [set LesCDNAsEnOverlap("EstCharge")]
}
set FichierOverlap "$RepertoireDuGenome/fiches/overlap_cdnas$Best"
if {[file exists $FichierOverlap]} {
foreach Ligne [LesLignesDuFichier $FichierOverlap] {
scan $Ligne "%s" NomLu
set LesCDNAsEnOverlap($NomLu) [lrange [split $Ligne " "] 1 end]
}
set LesCDNAsEnOverlap("EstCharge") {}
return [LesCDNAsEnOverlap $Nom]
}
if { ! [OuiOuNon "Do I create $FichierOverlap ?"]} {
set LesCDNAsEnOverlap("EstCharge") [list "NoValues"]
return [set LesCDNAsEnOverlap("EstCharge")]
}
set LesAf [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trif$Best"]
set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid$Best"]
set iAf -1
set iCd 0
set PrecedentiCd $iCd
foreach Af $LesAf {
incr iAf
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
Espionne "[string repeat " " 40] $Af"
set iCd $PrecedentiCd
while {1} {
set Cd [lindex $LesCd $iCd]
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
Espionne "\n $Af\n$Cd"
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { break }
if {"$ChroAf $ContigAf" > "$ChroCd $ContigCd"} {
Espionne "[string repeat " " 40] $ChroAf $ContigAf > $ChroCd $ContigCd"
incr iCd
continue
}
if {$FinCd<$DebutAf} {
Espionne "[string repeat " " 40] $FinCd<$DebutAf"
incr iCd
continue
}
Espionne "je me lance dans\n $Af\n$Cd"
break
}
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { continue }
for {set PrecedentiCd $iCd} {$iCd < [llength $LesCd]} { incr iCd } {
set Cd [lindex $LesCd $iCd]
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
if {[CetOrdre $Af $Cd]} { break }
if {$FinCd < $DebutAf} { continue }
if {$NomCd==$NomAf} { continue }
Espionne " $Af\n$Cd overlap"
lappend LesCDNAs($NomCd) $NomAf
}
}
foreach Nom [array names LesCDNAs] {
set LesAffys [lsort -unique [set LesCDNAs($Nom)]]
AppendAuFichier $FichierOverlap "$Nom [join $LesAffys " "]"
}
return [LesCDNAsEnOverlap $Nom]
}
proc Cousins args {
global RepertoireDuGenome
set FichierDesCousins "cousins"
File delete -force $FichierDesCousins
set RepertoireRacine [file dirname $RepertoireDuGenome]
foreach Gdb $args {
set Rep "$RepertoireRacine/$Gdb"
foreach Fichier [glob -nocomplain "$Rep/nuctfa/*"] {
set Nom "$Gdb/nuctfa/[file tail $Fichier]"
if { ! [file exists $Fichier]} { continue }
set Seq [QueLaSequenceDuTFA $Fichier]
lappend LesSeqNom "$Seq $Nom"
}
}
set LesSeqNom [lsort $LesSeqNom]
lappend LesSeqNom "bidon bidon"
set OldSeq "zzzzzz"
set LaSortie {}
foreach SeqNom $LesSeqNom {
scan $SeqNom "%s %s" Seq Nom
if {$OldSeq==$Seq} {
if { ! [info exists LesMemes]} { set LesMemes $OldNom }
lappend LesMemes $Nom
} else {
if {[info exists LesMemes]} {
Espionne [join $LesMemes " "]
lappend LaSortie [join $LesMemes " "]
unset LesMemes
}
}
Espionne "[string range $Seq 0 80] [string length $Seq]"
set OldSeq $Seq
set OldNom $Nom
}
if {$LaSortie=={}} {
Sauve "No cusins were found" dans $FichierDesCousins
} else {
SauveLesLignes $LaSortie dans $FichierDesCousins
}
return $FichierDesCousins
}
proc Jumeaux {{Source ""} {Rep ""}} {
while {$Source=="" || $Source =="Ask"} {
set Source [ChoixParmi [list "NoTwinsAtAll" "SeqNuc" "LocChroContig" "Overlap"]]
if {$Source!=""} { break }
}
set FichierDesJumeaux "[RepertoireDuGenome]/fiches/jumeaux_$Source"
while {[file exists $FichierDesJumeaux]} {
if {[OuiOuNon "$FichierDesJumeaux already exists.\n\ Do I replace it ?"]} {
File delete -force $FichierDesJumeaux
break
}
if {[OuiOuNon "$FichierDesJumeaux already exists.\n\ Do I keep it ?"]} {
return $FichierDesJumeaux
}
}
set LesSeqNom {}
if {$Source=="Overlap"} {
return [ClustersDeClonesAuxLocsChevauchantes]
}
if {$Source=="SeqNuc"} {
if {$Rep==""} { set Rep "[RepertoireDuGenome]/nuctfa" }
foreach Nom [ListeDesPABs] {
set Fichier "$Rep/$Nom"
if { ! [file exists $Fichier]} { continue }
set Seq [string toupper [QueLaSequenceDuTFA $Fichier]]
lappend LesSeqNom "$Seq $Nom"
}
}
if {$Source=="LocChroContig"} {
foreach Nom [ListeDesPABs] {
set LesLocCC [LesLocalisationsSurChroContig $Nom]
if {$LesLocCC=={}} { continue }
set LocCC [lindex $LesLocCC 0]
regsub { [+\-]} $LocCC "" LocCC
regsub -all { } $LocCC "_" LocCC
lappend LesSeqNom "$LocCC $Nom"
}
}
set LesSeqNom [lsort $LesSeqNom]
lappend LesSeqNom "bidon bidon"
set OldSeq "zzzzzz"
set LaSortie {}
foreach SeqNom $LesSeqNom {
scan $SeqNom "%s %s" Seq Nom
if {$OldSeq==$Seq} {
if { ! [info exists LesMemes]} { set LesMemes $OldNom }
lappend LesMemes $Nom
} else {
if {[info exists LesMemes]} {
lappend LaSortie [join $LesMemes " "]
unset LesMemes
}
}
set OldSeq $Seq
set OldNom $Nom
}
if {$LaSortie=={}} {
Sauve "No twins were found" dans $FichierDesJumeaux
} else {
SauveLesLignes $LaSortie dans $FichierDesJumeaux
}
return $FichierDesJumeaux
}
proc CodeCloneDuAffymetrix Affy {
set AssoAffy [AffymetrixAssocie]
if {$AssoAffy=="NoAssociatedAffymetrix"} { return "NoAssociatedAffymetrix" }
set CC [QuestionDeScience $AssoAffy "ret CodeClone $Affy"]
return $CC
}
proc VoirLaMeilleureLocalisationDuCDNA Nom {
Wup "Shows the first localisation of Nom"
Gs "Canvas"
set Loc [MeilleureLocalisationSurChroContig $Nom]
if {[regexp "Chro0 Contig00" $Loc]} { return "" }
scan $Loc "%s %s" Chro Contig
return [VoirLesLocalisations $Chro $Contig]
}
proc VoirLesLocalisationsDuCDNA {Nom {Selection ""}} {
Wup "Shows all localisations of Nom if Selection is empty, otherwise only these from Selection"
set K ""
if {$Selection==""} {
set Selection [join [ChaqueSegmentDuBlastN $Nom 0.001 {}] "\n"]
}
foreach Ligne [split $Selection "\n"] {
scan $Ligne "%s" ChroContig
ScanLaListe [split $ChroContig ":"] Chro Contig
regsub {_[0-9]+} $Contig "" Contig
set K [VoirLesLocalisations $Chro $Contig]
}
return $K
}
proc VoirLesLocalisations {Chro Contig} {
Gs "Canvas"
JeMeSignale
set Minimum 999999999
set Maximum -999999999
set ChroContig "${Chro}_$Contig"
set Maximum [ContigEnStock "$ChroContig" "SizePlease"]
if {$Maximum==""} { return "" }
set LesBornes [LesBornesDeChroContig $Chro $Contig]
foreach Ligne $LesBornes {
scan $Ligne "%s %d %d %s" Nom D F O
set Minimum [Mini $Minimum $D]
set Maximum [Maxi $Maximum $F]
}
set LesLocGenscan [LesProteinesPreditesDuGenscan $ChroContig "Loc"]
foreach Loc $LesLocGenscan {
scan $Loc "%d %d %s %s" D F O P
set Maximum [Maxi $Maximum $F]
lappend LesLocs $Loc
}
set SX 800
set SY 800
set MX [expr $Maximum + 50]
set LargeurMini 20
set MY $SY
set BY 100
set K [UnCanva $MX $MY $SX $SY]
regsub ".canvas$" $K "" w
set Y 0
set OldFPAB -999
set OldFAFF -999
foreach Ligne $LesBornes {
scan $Ligne "%s %d %d %s" Nom D F O
if {[info exists DejaVu($Nom)]} { continue }
set DejaVu($Nom) 1
if {$O=="F"} { set C "blue" } else { set C "red" }
if {[EstUnPAB $Nom]} {
set DeltaY -30
if {[expr $OldFPAB < $D]} {
set Y [expr $MY/2 - $BY]
} else {
incr Y $DeltaY
}
set OldFPAB $F
} else {
set DeltaY 30
if {[expr $OldFAFF < $D]} {
set Y [expr $MY/2 + $BY]
} else {
incr Y $DeltaY
}
set OldFAFF $F
}
set Dm $D
set Fm $F
if {0 && [expr ($F-$D)*1.*$SX/$Maximum < $LargeurMini]} {
set Dm [expr ($D+$F)/2-$LargeurMini*$Maximum/(2.*$SX)]
set Fm [expr ($D+$F)/2+$LargeurMini*$Maximum/(2.*$SX)]
}
if {[EstUnPAB $Nom]} {
set NdS [NomDeScene $Nom]
} else {
set NdS $Nom
}
set IdR [$K create rectangle $Dm [expr $Y-10] $Fm [expr $Y+10] -fill "white"]
set IdT [$K create text [expr ($D+$F)/2] $Y -text $NdS -anchor c -fill $C -tags [list "CDNA" $Nom "$D $F $O"]]
if {[EstUnPAB $Nom]} {
$K itemconfigure $IdR -tags [list "Box" $Nom "FetchMe" "CDNA" "$D $F $O"]
$K itemconfigure $IdT -tags [list "Box" $Nom "FetchMe" "CDNA" "$D $F $O"]
}
}
$K bind "CDNA" <Enter> "Devoile $K %x %y"
$K bind "CDNA" <Leave> "Devoile $K %x %y Efface"
$K bind "FetchMe" <1> "FetcheBox $K %x %y"
$K bind "FetchMe" <3> "FetcheBox $K %x %y"
$K bind "FetchMe" <2> "SearchOnBoard \[NomDuCourant $K\]"
$K create rectangle 0 [expr $MY/2-1] $Maximum [expr $MY/2+1] -fill "black"
$K create text [expr ($Maximum)/2] [expr $MY/2+30] \
-text "$Chro $Contig $Maximum bases" \
-tags [list "ChroContig"] \
-anchor c -fill "black"
$K bind "ChroContig" <1> "AfficheContigComplet ${Chro}_$Contig"
$K bind "ChroContig" <3> "AfficheContigComplet ${Chro}_$Contig"
set Ecart 5
foreach Loc $LesLocGenscan {
scan $Loc "%d %d %s %s" D F O P
if {$O=="+"} { set Couleur "blue"} else { set Couleur "red" }
set Ecart [expr -$Ecart]
set Haut [expr $MY/2-$Ecart-10]
set Bas [expr $MY/2-$Ecart+10]
$K create rectangle $D $Haut $F $Bas \
-fill $Couleur -outline $Couleur \
-tag [list "Box" "Predite" "$D $F $O $ChroContig $P"]
}
$K bind "Predite" <Enter> "Devoile $K %x %y"
$K bind "Predite" <Leave> "Devoile $K %x %y Efface"
$K bind "Predite" <3> "Devoile $K %x %y GenScan"
wm title $w "Localisation on $Chro $Contig"
Gonfle $w all [expr (1.*$SX)/$MX] 1.0
if { 0 && [PourWscope] } {
return [winfo toplevel $K]
}
return $K
}
proc LesBornesDeChroContig {Chro Contig} {
global RepertoireDuGenome
set AA [AffymetrixAssocie]
if {$AA==""} {
set LesAd {}
set LesAf {}
} else {
set LesAd [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trid.best"]
set LesAf [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trif.best"]
}
set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid.best"]
set LesCf [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trif.best"]
lappend $LesAf "Fin HZ"
lappend $LesCd "Fin HZ"
set iAd 0
set iAf 0
set iCd 0
set iCf 0
set LesBornes {}
foreach LesAouC [list $LesAf $LesCd] {
set iAf 0
set longAf [llength $LesAouC]
while {$iAf<$longAf} {
set Af [lindex $LesAouC $iAf]
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
if {$SensAf=="+"} { set SensAf "F" } else { set SensAf "R" }
if {"$Chro $Contig" > "$ChroAf $ContigAf"} { incr iAf ; continue }
if {"$Chro $Contig" < "$ChroAf $ContigAf"} { break }
if { ! [regexp $Contig $ContigAf]} { incr iAf ; continue }
lappend LesBornes "$NomAf $DebutAf $FinAf $SensAf"
incr iAf
}
}
return $LesBornes
}
proc CetOrdre {Af Cd} {
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { return 1 }
if {"$ChroAf $ContigAf" > "$ChroCd $ContigCd"} { return 0 }
return [expr $FinAf < $DebutCd]
}
proc LesCodeCloneDesAffymetrixEnOverlap Nom {
set LesAffys [LesAffymetrixEnOverlap $Nom]
set LesCC {}
foreach Affy $LesAffys {
set CC [CodeCloneDuAffymetrix $Affy]
if {$CC==""} { continue }
lappend LesCC $CC
}
return $LesCC
}
proc LesAffymetrixEnOverlap Nom {
global LesAffymetrixEnOverlap
global RepertoireDuGenome
set AA [AffymetrixAssocie]
if {$AA==""} { return {} }
if {[info exists LesAffymetrixEnOverlap($Nom)]} {
return [set LesAffymetrixEnOverlap($Nom)]
}
if {[info exists LesAffymetrixEnOverlap("EstCharge")]} {
return [set LesAffymetrixEnOverlap("EstCharge")]
}
set FichierOverlap "$RepertoireDuGenome/fiches/overlap_affymetrix"
if {[file exists $FichierOverlap]} {
foreach Ligne [LesLignesDuFichier $FichierOverlap] {
scan $Ligne "%s" NomLu
set LesAffymetrixEnOverlap($NomLu) [lrange [split $Ligne " "] 1 end]
}
set LesAffymetrixEnOverlap("EstCharge") {}
return [LesAffymetrixEnOverlap $Nom]
}
if { ! [OuiOuNon "Do I create $FichierOverlap ?"]} {
set LesAffymetrixEnOverlap("EstCharge") [list "NoValues"]
return [set LesAffymetrixEnOverlap("EstCharge")]
}
set LesAf [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trif"]
set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid"]
set iAf -1
set iCd 0
set PrecedentiCd $iCd
set MaxiCd [llength $LesCd]
foreach Af $LesAf {
incr iAf
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
Espionne "[string repeat " " 40] $Af"
set iCd $PrecedentiCd
while {$iCd<$MaxiCd} {
set Cd [lindex $LesCd $iCd]
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
# Espionne "\n $Af\n$Cd"
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { break }
if {"$ChroAf $ContigAf" > "$ChroCd $ContigCd"} {
# Espionne "[string repeat " " 40] $ChroAf $ContigAf > $ChroCd $ContigCd"
incr iCd
continue
}
if {$FinCd<$DebutAf} {
# Espionne "[string repeat " " 40] $FinCd<$DebutAf"
incr iCd
continue
}
# Espionne "je me lance dans\n $Af\n$Cd"
break
}
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { continue }
for {set PrecedentiCd $iCd} {$iCd < [llength $LesCd]} { incr iCd } {
set Cd [lindex $LesCd $iCd]
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
if {[CetOrdre $Af $Cd]} { break }
if {$FinCd < $DebutAf} { continue }
# Espionne " $Af\n$Cd overlap"
lappend LesAffymetrix($NomCd) $NomAf
}
}
foreach NomCd [array names LesAffymetrix] {
set LesAffys [lsort -unique [set LesAffymetrix($NomCd)]]
AppendAuFichier $FichierOverlap "$NomCd [join $LesAffys " "]"
}
return [LesAffymetrixEnOverlap $Nom]
}
proc TriLesLocalisations {{BestOnly ""}} {
global RepertoireDuGenome
set BestOnly [regexp -nocase "BestOnly" $BestOnly]
if {$BestOnly} { set Best ".best" } else { set Best "" }
set FichLoc "$RepertoireDuGenome/fiches/localisationchrocontig"
set FichTrD "$RepertoireDuGenome/fiches/localisationchrocontig.trid$Best"
set FichTrF "$RepertoireDuGenome/fiches/localisationchrocontig.trif$Best"
if { ! [file exists $FichLoc]} { return [list {} {}] }
while {[file exists $FichTrD]} {
if {[OuiOuNon "$FichTrD already exists. Do I use it ?"]} {
return [list [LesLignesDuFichier $FichTrD] [LesLignesDuFichier $FichTrF]]
}
if {[OuiOuNon "$FichTrD already exists. Do I overwrite it ?"]} {
File delete -force $FichTrD
File delete -force $FichTrF
} else {
if {[OuiOuNon "Do I stop ?"]} { exit }
}
}
foreach Ligne [LesLignesDuFichier $FichLoc] {
scan $Ligne "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
if {$BestOnly && [info exists Dejavu($Nom)]} { continue }
set Dejavu($Nom) 1
set CC "$Chro $Contig"
lappend LesLocsDesCC($CC) $Ligne
if { ! [info exists DejaVu($CC)]} { lappend LesCC $CC }
set DejaVu($CC) 1
}
set LesCCT [lsort $LesCC]
foreach CC $LesCCT {
set LesDebuts {}
set LesFins {}
if {[info exists DejaDebut]} { unset DejaDebut ; unset LesLocsDesDebuts}
if {[info exists DejaFin]} { unset DejaFin ; unset LesLocsDesFins}
foreach Ligne [set LesLocsDesCC($CC)] {
scan $Ligne "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
lappend LesLocsDesDebuts($Debut) $Ligne
if { ! [info exists DejaDebut($Debut)]} { lappend LesDebuts $Debut }
set DejaDebut($Debut) 1
lappend LesLocsDesFins($Fin) $Ligne
if { ! [info exists DejaFin($Fin)]} { lappend LesFins $Fin }
set DejaFin($Fin) 1
}
set LesDebuts [lsort -integer $LesDebuts]
set LesFins [lsort -integer $LesFins]
foreach Debut $LesDebuts {
AppendAuFichier $FichTrD [join [set LesLocsDesDebuts($Debut)] "\n"]
}
foreach Fin $LesFins {
AppendAuFichier $FichTrF [join [set LesLocsDesFins($Fin)] "\n"]
}
}
return [list [LesLignesDuFichier $FichTrD] [LesLignesDuFichier $FichTrF]]
}
proc LesMeilleursCopainsDuBlast {Nom {Rep "blastngenembl"}} {
global LesMeilleursCopainsDuBlast
global RepertoireDuGenome
if {[info exists LesMeilleursCopainsDuBlast($Nom,$Rep)]} {
return [set LesMeilleursCopainsDuBlast($Nom,$Rep)]
}
if {[info exists LesMeilleursCopainsDuBlast("EstCharge",$Rep)]} {
return [set LesMeilleursCopainsDuBlast("EstCharge",$Rep)]
}
set Fichier "$RepertoireDuGenome/fiches/cops_$Rep"
if { ! [file exists $Fichier]} {
set LesMeilleursCopainsDuBlast("EstCharge",$Rep) [list "File not yet available"]
return [set LesMeilleursCopainsDuBlast("EstCharge",$Rep)]
}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s" NomLu
regsub "$NomLu " $Ligne "" Cop
lappend LesMeilleursCopainsDuBlast($NomLu,$Rep) $Cop
}
set LesMeilleursCopainsDuBlast("EstCharge",$Rep) [list "No value"]
return [LesMeilleursCopainsDuBlast $Nom $Rep]
}
proc MeilleursCopainsDuBlastPourTous {{Rep "blastngenembl"} {CutPN ""} {MaxListe ""}} {
global RepertoireDuGenome
Wup "Creates the file and returns its name. Returns an empty string if nothing found"
set Fichier "$RepertoireDuGenome/fiches/cops_$Rep"
if {[file exists $Fichier]} {
if {[OuiOuNon "Do I keep existing results found in $Fichier ?"]} {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" Nom
lappend LesOldCops($Nom) $Ligne
}
if {[info exists Nom]} { unset LesOldCops($Nom) }
}
File rename -force $Fichier $Fichier.copie
File delete -force $Fichier
}
foreach Nom [ListeDesPABs] {
Espionne "Je vais chercher les cops dans $Rep de $Nom"
if {[info exists LesOldCops($Nom)]} {
AppendAuFichier $Fichier [join $LesOldCops($Nom) "\n"]
continue
}
set LesCops [MeilleursCopainsDuBlast $Nom $Rep]
if {$LesCops=={}} { continue }
AppendAuFichier $Fichier [join $LesCops "\n"]
}
if {[file exists $Fichier]} {
return $Fichier
} else {
return ""
}
}
proc MeilleursCopainsDuBlast {Nom {Rep "blastngenembl"} {CutPN ""} {MaxListe ""}} {
global RepertoireDuGenome
if {$CutPN==""} { set CutPN 0.001 }
if {$MaxListe==""} { set MaxListe 5 }
if {[EstUnPAB $Nom]} {
set FichierBlast "$RepertoireDuGenome/$Rep/$Nom"
} else {
set FichierBlast $Nom
}
if { ! [file exists $FichierBlast]} { return {} }
set LesR {}
DecortiqueBlast $FichierBlast $CutPN $MaxListe Query lBanqueId lAccess lDE lProfil lPN
foreach BanqueId $lBanqueId Access $lAccess DE $lDE Profil $lProfil PN $lPN {
if {[regexp -nocase "sapiens" $DE]} {
set OS "Homo sapiens"
} else {
set OS "Inconnu inconnu"
}
set R "$Nom $BanqueId $Access $PN $OS $DE"
set LeEMBL [LaSequenceDesBanques $BanqueId $Access a "OnVeutEMBL"]
if {$LeEMBL!={}} {
set OS "Inconnu inconnu"
set LaDef {}
foreach Ligne $LeEMBL {
if {[regexp "^OS " $Ligne]} {
set Genre "Inconnu"
set Espece "inconnu"
scan $Ligne "%s %s %s" Bidon Genre Espece
if {[regexp -nocase "Mitochondrion Homo" "$Genre $Espece"]} {
set OS "Homo sapiens"
} else {
set OS "$Genre $Espece"
}
regsub {\.$} $OS "" OS
continue
}
if {[regexp "^DE " $Ligne]} {
regsub "^DE " $Ligne "" Ligne
set Ligne [string trim $Ligne]
lappend LaDef $Ligne
}
}
if {$LaDef!={}} { set DE [join $LaDef " "] }
set R "$Nom $BanqueId $Access $PN $OS $DE"
}
lappend LesR $R
}
if {$LesR=={}} { set LesR [list "$Nom No hits found"] }
return $LesR
}
proc MeilleurPdbDuBlast {Nom {Rep ""} {CutPN ""} {MaxListe ""}} {
if {$Rep==""} { set Rep "blastp" }
if {$CutPN==""} { set CutPN 0.001 }
if {$MaxListe==""} { set MaxListe 999 }
if {[EstUnPAB $Nom]} {
set FichierBlast "[RepertoireDuGenome]/$Rep/$Nom"
} else {
set FichierBlast $Nom
}
if { ! [file exists $FichierBlast]} { return "" }
set LesR {}
DecortiqueBlast $FichierBlast $CutPN $MaxListe Query lBanqueId
foreach BId $lBanqueId {
if {[EstUnAccessPDB $BId]} { return $BId }
}
return ""
}
proc MeilleurPdbDuMsf {Nom {Rep ""} {Query ""}} {
Wup "Query peut etre Nom ou un access ou 'QueryInFirstPlace'"
if {$Query==""} { set Query [file tail $Nom] }
if {$Rep==""} { set Rep "msf" }
if {[EstUnPAB $Nom]} {
set FichierMsf "[RepertoireDuGenome]/$Rep/$Nom"
} else {
set FichierMsf $Nom
}
if { [FileAbsent $FichierMsf]} { return "" }
set LeR [IdentiteEtSimilariteDansMSF $FichierMsf $Query]
set LeR [lsort -decreasing -command CompareLeDeuxiemeChamp $LeR]
foreach R $LeR {
scan $R "%s %f %f" Hit PI PS
if {[EstUnAccessPDB $Hit]} { return $Hit }
}
return ""
}
proc ConsacreVersusPredite Nom {
global RepertoireDuGenome
global ConsacreVersusPredite
if {[info exists ConsacreVersusPredite($Nom)]} { return [set ConsacreVersusPredite($Nom)] }
if {[info exists ConsacreVersusPredite("EstCharge")]} { return [set ConsacreVersusPredite("EstCharge")] }
set Fichier "$RepertoireDuGenome/fiches/consacre_versus_predite"
if {[file exists $Fichier]} {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" NomLu
regsub "$NomLu *" $Ligne "" Valeur
if {$Valeur==""} { set Valeur "OK" }
set ConsacreVersusPredite($NomLu) $Valeur
}
set ConsacreVersusPredite("EstCharge") "No value"
return [ConsacreVersusPredite $Nom]
}
set ConsacreVersusPredite("EstCharge") "No values available"
return [set ConsacreVersusPredite("EstCharge")]
}
proc TBlastNDuConsacreDeLaPreditePourTous {{Banque "est"}} {
global RepertoireDuGenome
set NomDeLaBanque "/catalog/blast/$Banque"
set FichierLog "$RepertoireDuGenome/fiches/consacre_versus_predite"
set Rep "$RepertoireDuGenome/tblastn$Banque"
if { ! [file exists $Rep]} { File mkdir $Rep }
set Keep 1
if {[llength [glob -nocomplain $Rep/*]]>0} {
if { ! [OuiOuNon "Some TBlastN against $Banque have already be made.\nDo I keep them ?"]} {
set Keep 0
} else {
if {[file exists $FichierLog]} {
File copy -force $FichierLog "${FichierLog}.copie"
foreach Ligne [LesLignesDuFichier $FichierLog] {
scan $Ligne "%s" NomLu
set TexteLog($NomLu) $Ligne
}
}
}
File delete -force $FichierLog
}
foreach Nom [ListeDesPABs] {
Espionne "Je vais lancer TBlastN $NomDeLaBanque pour $Nom"
set FichierBlast "$Rep/$Nom"
if {$Keep && [file exists $FichierBlast]} {
if {[info exists TexteLog($Nom)]} {
AppendAuFichier $FichierLog [set TexteLog($Nom)]
}
continue
}
set FichierPredite "$RepertoireDuGenome/genscanpredictions/$Nom"
if { ! [file exists $FichierPredite]} {
AppendAuFichier $FichierLog "$Nom no GenScan prediction available"
continue
}
set TfaP [ContenuDuFichier $FichierPredite]
set SeqP [QueLaSequenceDuTexteTFA $TfaP]
set LongP [string length $SeqP]
if {$LongP < 10} {
AppendAuFichier $FichierLog "$Nom less than 10 aa in GenScan prediction"
continue
}
set Consacre [lindex [MeilleursCopains $Nom] 0]
if {[regexp "^No " $Consacre]} { continue }
scan $Consacre "%s %s" BID Access
set LesLignesEMBL [LaSequenceDesBanques $BID $Access AccessOK "OnVeutEMBL"]
if {$LesLignesEMBL=={}} {
AppendAuFichier $FichierLog "$Nom $BID $Access not found"
continue
}
set TfaC [SequenceFormatTFA_l $LesLignesEMBL $AccessOK "embl"]
set SeqC [QueLaSequenceDuTexteTFA $TfaC]
set LongC [string length $SeqC]
if {$LongC < 10} {
AppendAuFichier $FichierLog "$Nom less than 10 aa in best blastp hit"
continue
}
set CsP [expr (1.0*$LongC)/$LongP]
if { 0.7 < $CsP && $CsP < 1.3 } {
set FichierTFA [Sauve $TfaC dans "[TmpFile].tfa"]
AppendAuFichier $FichierLog "$Nom"
} elseif { $LongC < $LongP } {
set FichierTFA [Sauve $TfaC dans "[TmpFile].tfa"]
AppendAuFichier $FichierLog "$Nom may be missing exons in predicted protein"
} else {
set FichierTFA $FichierPredite
AppendAuFichier $FichierLog "$Nom may be surnumerous exons or merged proteins in predicted protein"
}
set CommandeTBlastN "blastall \
-p tblastn \
-i $FichierTFA \
-o ${FichierBlast}.encours \
-d $NomDeLaBanque \
-v 125 \
-K 0 \
-b 125 \
-e 10.0 \
-F T "
eval exec $CommandeTBlastN
if {[file exists ${FichierBlast}.encours]} {
file rename -force ${FichierBlast}.encours $FichierBlast
}
}
}
proc CreeTousLesRapportsPourAccess {{Start ""} {Keep ""}} {
global RepertoireDuGenome
set RepRapports "$RepertoireDuGenome/rapportsaccess"
if { ! [file exists $RepRapports]} { File mkdir $RepRapports }
if {$Keep==""} { set Keep 0 } else { set Keep 1 }
foreach Nom [ListeDesPABs] {
Espionne $Nom
if {$Start!="" && $Nom!=$Start} { continue }
set Start ""
if {$Keep && [file exists "$RepRapports/$Nom"]} { continue }
set Rapport {}
#Generalites
lappend Rapport "GscopeCode: $Nom"
set codeCl [CodeClone $Nom]
set User [OwnerOfCDNA $Nom]
lappend Rapport "CodeClone: $codeCl"
lappend Rapport "User: $User"
set JR [JumeauRepresentatif $Nom]
if {$JR!=$Nom && $JR!=""} {
set CC [CodeClone $JR]
lappend Rapport "JR: $CC $JR"
}
#RepeatMasker
set TypeMask [QuelMask $Nom]
Espionne $TypeMask
set PourcentMask [ExtraitInfo $Nom "RMPourcent"]
lappend Rapport "MaskType: $TypeMask"
lappend Rapport "MaskedProportion: $PourcentMask"
set TypeRepeat [ExtraitInfo $Nom "RM"]
if { $TypeRepeat!="" } {
lappend Rapport "RepeatType: $TypeRepeat"
}
#BlastN contre le genome humain
set PolyLoc [PolyLocalise $Nom]
Espionne $PolyLoc
lappend Rapport "LocType: $PolyLoc"
if { $PolyLoc!="NoBlastFile" && $PolyLoc!="NoLocalization"} {
set LesLocs [LesLocalisationsSurChroContig $Nom]
set MeilleureLoc [lindex $LesLocs 0]
scan $MeilleureLoc "%s %s %d %d %s" Chro Contig Debut Fin Orient
regsub "HS" $Chro "" Chro
lappend Rapport "Chromosome: $Chro"
lappend Rapport "Contig: $Contig"
lappend Rapport "Begin: $Debut"
lappend Rapport "End: $Fin"
lappend Rapport "Orientation: $Orient"
}
#GenScan
set GS [ExtraitInfo $Nom "GS"]
if {$GS == "overlap found with a predicted protein"} { lappend Rapport "InAPredictedGene: 1" }
if {$GS == "no overlap found with a predicted protein"} { lappend Rapport "InAPredictedGene: 0" }
set GS3 [ExtraitInfo $Nom "GS3"]
if {$GS3 == "in 3' region"} { lappend Rapport "InPredicted3Region: 1" }
if {$GS3 == "not in 3' region"} { lappend Rapport "InPredicted3Region: 0" }
set GSE [ExtraitInfo $Nom "GSE"]
if {$GSE == "in an exon"} { lappend Rapport "InAPredictedExon: 1" }
if {$GSE == "not in an exon"} { lappend Rapport "InAPredictedExon: 0" }
#BlastP
set LesCopains [MeilleursCopains $Nom]
if {$LesCopains != {} } {
set MeilleurCopain [lindex $LesCopains 0]
if {$MeilleurCopain=="No hits found" || \
$MeilleurCopain=="No human protein with expect less than 1.e-3 in the BlastP results" || \
$MeilleurCopain=="No blastp file available" } {
lappend Rapport "BlastPDef: $MeilleurCopain"
} else {
set Access ""
set PlusieursFonctions 0
scan $MeilleurCopain "%s %s" BID Access
regsub "$BID $Access" $MeilleurCopain "" PremDef
set PremDef [string trim $PremDef]
lappend Rapport "BlastPAccess: $BID"
lappend Rapport "BlastPDef: $PremDef"
if {[expr [llength $LesCopains] > 1]} {
foreach Cop [lrange $LesCopains 1 end] {
scan $Cop "%s %s" BID Access
set Definition [join [lrange [split $Cop " "] 2 end] " "]
if {$Definition!=$PremDef} {set PlusieursFonctions 1 ; break}
}
}
lappend Rapport "BlastPMore: $PlusieursFonctions"
}
set CvP [ConsacreVersusPredite $Nom]
if {$CvP!="No values"} {
lappend Rapport "Prediction_vs_BlastPHit: $CvP"
}
}
#BlastX
set LesCopains [LesMeilleursCopainsDuBlast $Nom "blastx"]
if {$LesCopains != {} } {
set MeilleurCopain [lindex $LesCopains 0]
if {[regexp -nocase "^no hit" $MeilleurCopain]} { set MeilleurCopain "No hits found" }
if {$MeilleurCopain=="No hits found" || \
$MeilleurCopain=="No human protein with expect less than 1.e-3 in the BlastX results" || \
$MeilleurCopain=="No blastx file available" } {
lappend Rapport "BlastXDef: $MeilleurCopain"
} else {
set Access ""
set PlusieursFonctions 0
scan $MeilleurCopain "%s %s" BID Access
regsub "$BID $Access" $MeilleurCopain "" PremDef
set PremDef [string trim $PremDef]
lappend Rapport "BlastXAccess: $BID"
lappend Rapport "BlastXDef: $PremDef"
if {[expr [llength $LesCopains] > 1]} {
foreach Cop [lrange $LesCopains 1 end] {
scan $Cop "%s %s" BID Access
set Definition [join [lrange [split $Cop " "] 2 end] " "]
if {$Definition!=$PremDef} {set PlusieursFonctions 1 ; break}
}
}
lappend Rapport "BlastXMore: $PlusieursFonctions"
}
}
#BlastN contre genembl et est, et TBlastN contre est
foreach {Banque Titre} {blastngenembl Genembl blastnest Est tblastnest TbnEst} {
set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque]
if {$LesCops=={}} {
lappend Rapport "${Titre}Def: values not yet available"
} elseif {[lindex $LesCops 0]=="File not yet available"} {
lappend Rapport "${Titre}Def: values not yet available"
} elseif {[lindex $LesCops 0]=="No value"} {
lappend Rapport "${Titre}Def: no value available"
} elseif {[lindex $LesCops 0]=="No hit"} {
lappend Rapport "${Titre}Def: no hit"
} else {
set PremiereFois 1
set Autre 0
foreach Cop $LesCops {
set Genre "Inconnu"
set Espece "inconnu"
scan $Cop "%s %s %s %s %s" BID Access Expect Genre Espece
set OS "$Genre $Espece"
set DE [join [lrange [split $Cop " "] 5 end] " "]
if { ! [regexp -nocase "Homo sapiens" $OS]} { continue }
if {$PremiereFois} {
lappend Rapport "${Titre}Def: $DE"
lappend Rapport "${Titre}Access: $BID"
set PremDE $DE
set PremiereFois 0
continue
}
if {$DE!=$PremDE} { incr Autre }
}
lappend Rapport "${Titre}More: [expr $Autre > 0]"
}
}
#Affymetrix overlaps
set LesCC [LesCodeCloneDesAffymetrixEnOverlap $Nom]
if {$LesCC!={}} {
set TexteAffy "Affymetrix: [join $LesCC " "]"
} else {
if {[AffymetrixAssocie]=="NoAssociatedAffymetrix"} {
set TexteAffy "Affymetrix: not tested"
} else {
set TexteAffy "Affymetrix: not detected"
}
}
lappend Rapport $TexteAffy
SauveLesLignes $Rapport dans "$RepRapports/$Nom"
}
return ""
}
proc CreeToutesLesNotesPourCDNA {{Start ""} {Keep ""}} {
global RepertoireDuGenome
set RepNotes "$RepertoireDuGenome/notes"
if { ! [file exists $RepNotes]} { File mkdir $RepNotes }
if {$Keep==""} { set Keep 0 } else { set Keep 1 }
foreach Nom [ListeDesPABs] {
Espionne $Nom
if {$Start!="" && $Nom!=$Start} { continue }
set Start ""
if {$Keep && [file exists "$RepNotes/$Nom"]} { continue }
set Note {}
#Identites
lappend Note "Name" "$Nom"
lappend Note "" ""
lappend Note "cDNA length" [string length [QueLaSequenceDuFichierTFA "$RepertoireDuGenome/nuctfa/$Nom"]]
lappend Note "" ""
set Clone [CodeClone $Nom]
set Owner [OwnerOfCDNA $Nom]
lappend Note "Code in the Access database" $Clone
lappend Note "Owner in the Access database" $Owner
if {[OnTraiteDesAffymetrix]} {
set Access [AffymetrixAccess $Nom]
set DE [ExtraitInfo $Nom "GBtagsDefinition"]
lappend Note "GBtags accession number" $Access
lappend Note "GBtags definition" $DE
}
set JR [JumeauRepresentatif $Nom]
if {$JR!=$Nom && $JR!=""} {
set CC [CodeClone $JR]
lappend Note "Same sequence as" "$JR $CC"
}
#RepeatMasker
set TypeMask [QuelMask $Nom]
Espionne $TypeMask
set PourcentMask [ExtraitInfo $Nom "RMPourcent"]
lappend Note "RepeatMasker results" "$TypeMask ( $PourcentMask % )"
set TypeRepeat [ExtraitInfo $Nom "RM"]
if { $TypeRepeat!="" } {
lappend Note "" "$Nom contains $TypeRepeat sequence(s)"
}
#BlastN contre le genome humain
set PolyLoc [PolyLocalise $Nom]
Espionne $PolyLoc
lappend Note "BlastN human results" $PolyLoc
if { $PolyLoc!="NoBlastFile" && $PolyLoc!="NoLocalization"} {
set LesLocs [LesLocalisationsSurChroContig $Nom]
foreach Loc $LesLocs {
scan $Loc "%s %s %d %d %s" Chr Cont Gauche Droite Orient
lappend Note "" "chromosome $Chr contig $Cont from $Gauche to $Droite ( $Orient )"
}
}
#GenScan
set GS [ExtraitInfo $Nom "GS"]
if {$GS != "" } {lappend Note "GenScan results" $GS}
set GS3 [ExtraitInfo $Nom "GS3"]
if {$GS3 != "" } {lappend Note "" "$Nom is $GS3"}
set GSE [ExtraitInfo $Nom "GSE"]
if {$GSE != "" } {lappend Note "" "$Nom is $GSE"}
#BlastP
set LesCopains [MeilleursCopains $Nom]
EspionneL $LesCopains
lappend Note "BlastP results" [lindex $LesCopains 0]
foreach Copain [lrange $LesCopains 1 end] {
lappend Note "" $Copain
}
set CvP [ConsacreVersusPredite $Nom]
if {$CvP!="No values"} {
lappend Note "Prediction_vs_BlastPHit" $CvP
}
#BlastX
set LesCopains [LesMeilleursCopainsDuBlast $Nom "blastx"]
EspionneL $LesCopains
lappend Note "BlastX results" [lindex $LesCopains 0]
foreach Copain [lrange $LesCopains 1 end] {
lappend Note "" $Copain
}
#BlastN contre genembl et est, et TBlastN contre est
foreach {Banque Titre} {tblastnest "TblastN Est" blastngenembl "BlastN Genembl" blastnest "BlastN Est"} {
set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque]
if {$LesCops=={}} {
lappend Note "$Titre results" "values not yet available"
} elseif {[lindex $LesCops 0]=="File not yet available"} {
lappend Note "$Titre results" "values not yet available"
} elseif {[lindex $LesCops 0]=="No value"} {
lappend Note "$Titre results" "no value available"
} elseif {[lindex $LesCops 0]=="No hit"} {
lappend Note "$Titre results" "no hit"
} else {
set PremiereFois 1
foreach Cop $LesCops {
set Genre "Inconnu"
set Espece "inconnu"
scan $Cop "%s %s %s %s %s" BID Access Expect Genre Espece
set OS "$Genre $Espece"
set DE [join [lrange [split $Cop " "] 5 end] " "]
if { ! [regexp -nocase "Homo sapiens" $OS]} { continue }
if {$PremiereFois} {
lappend Note "$Titre results" "$BID $Access $Expect $DE"
set PremiereFois 0
continue
} else {
lappend Note "" "$BID $Access $Expect $DE"
}
}
}
}
#Affymetrix overlaps
set LesAffys [LesAffymetrixEnOverlap $Nom]
if {$LesAffys!={}} {
set TexteAffy "[join $LesAffys " "]"
} else {
if {[AffymetrixAssocie]=="NoAssociatedAffymetrix"} {
set TexteAffy "not tested"
} else {
set TexteAffy "not detected"
}
}
lappend Note "Affymetrix" $TexteAffy
#Traitement pour tous
set LesLignes {}
foreach {T V} $Note {
if {$T=="Name"} {
lappend LesLignes $Nom
continue
}
if {$T!="" || $V!=""} {
set L [expr 30 - [string length $T]]
if {$T!=""} { set C "." ; set S ":" } else { set C " " ; set S " " }
set P [string repeat $C $L]
lappend LesLignes [format "%s %s %s %s" $T $P $S $V]
} else {
lappend LesLignes ""
}
}
SauveLesLignes $LesLignes dans "$RepNotes/$Nom"
}
return ""
}
proc DecortiqueBlastPCDNA {BanqueID Hit Quoi {Fichier ""} {MaxAccess -1} {MaxHitsParAccess -1} } {
global DecortiqueBlastPCDNA
if {$Fichier==""} {
if {[info exists DecortiqueBlastPCDNA($BanqueID,$Hit,$Quoi)]} {
return [set DecortiqueBlastPCDNA($BanqueID,$Hit,$Quoi)]
}
return {}
} else {
if {[info exists DecortiqueBlastPCDNA]} { unset DecortiqueBlastPCDNA }
}
set LesLignes [LesLignesDuFichier $Fichier]
if {[lsearch -regexp [lrange $LesLignes 0 30] "No hits found"] != -1} { return 0 }
set IndexSPSA [lsearch -regexp $LesLignes "Sequences producing significant alignments"]
if { $IndexSPSA == -1 } { return 0 }
set PartieRestante [lrange $LesLignes [incr IndexSPSA 2] end]
set IndexPremierChevron [lsearch -regexp $PartieRestante {^>}]
if { $IndexPremierChevron == -1 } { return 0 }
set PartieScores [lrange $PartieRestante 0 [expr $IndexPremierChevron-1]]
set PartieSegAli [lrange $PartieRestante $IndexPremierChevron end]
set EncoreUnAccess $MaxAccess
foreach Ligne $PartieSegAli {
if { $Ligne == "" } { continue }
if { [regexp "^>" $Ligne] } {
if { ! [incr EncoreUnAccess -1]} { break }
set EncoreUnHit $MaxHitsParAccess
set NumHit 0
set CurrentAccess ""
scan $Ligne "%s %s" CurrentBID CurrentAccess
regsub ">" $CurrentBID "" CurrentBID
regsub "^>$CurrentBID" $Ligne "" Ligne
set LesMots [split $Ligne " "]
if {[EstUnAccessPDB $CurrentBID]} {
set DefProt [join [lrange $LesMots 1 end] " "]
} else {
set DefProt [join [lrange $LesMots 2 end] " "]
}
# lappend LesBIDs $CurrentBID
set Def($CurrentBID) $DefProt
set Acc($CurrentBID) $CurrentAccess
continue
}
if { [regexp "Length" $Ligne] } {
regsub "^ *Length = " $Ligne "" Ligne
scan $Ligne "%d" Long
set LongProt($CurrentBID) $Long
continue
}
if { [regexp "Expect" $Ligne] } {
incr NumHit
set E [PNApres "Expect =" dans $Ligne]
set Expect($CurrentBID,$NumHit) $E
continue
}
if { [regexp "Identities" $Ligne] } {
regsub -all "," $Ligne "" Ligne
regsub -all {\(*\)} $Ligne "" Ligne
set nId [IntegerApres "Identities =" dans $Ligne]
set nTot [IntegerApres "/" dans $Ligne]
set nGaps [IntegerApres "Gaps =" dans $Ligne]
if {$nGaps==""} { set nGaps 0 }
set Identites($CurrentBID,$NumHit) $nId
set Gaps($CurrentBID,$NumHit) $nGaps
set LongHit($CurrentBID,$NumHit) $nTot
if { ! [info exists DejaVu($CurrentBID)]} {
lappend LesBIDs $CurrentBID
set DejaVu($CurrentBID) 1
}
if { ! [incr EncoreUnHit -1]} { break }
lappend LesHits($CurrentBID) $NumHit
}
}
set DecortiqueBlastPCDNA(All,All,Numbers) $LesBIDs
foreach B $LesBIDs {
set DecortiqueBlastPCDNA($B,All,DefProt) [set Def($B)]
set DecortiqueBlastPCDNA($B,All,Access) [set Acc($B)]
set DecortiqueBlastPCDNA($B,All,LongProt) [set LongProt($B)]
set DecortiqueBlastPCDNA($B,All,Numbers) [set LesHits($B)]
foreach H [set LesHits($B)] {
set DecortiqueBlastPCDNA($B,$H,Identites) [set Identites($B,$H)]
set DecortiqueBlastPCDNA($B,$H,Gaps) [set Gaps($B,$H)]
set DecortiqueBlastPCDNA($B,$H,Expect) [set Expect($B,$H)]
set DecortiqueBlastPCDNA($B,$H,LongHit) [set LongHit($B,$H)]
}
}
return [DecortiqueBlastPCDNA $BanqueID $Hit $Quoi]
}
proc MeilleursCopains {Nom {Organisme "Homo sapiens"}} {
global RepertoireDuGenome
Wup "Return BID Access Definition of the best blastp hits ('best' means high score and %)"
if {[EstUnPAB $Nom]} {
set FichierBlast "[RepertoireDuGenome]/blastp/$Nom"
} else {
set FichierBlast $Nom
}
if { ! [file exists $FichierBlast]} { return [list "No blastp file available"] }
Espionne $FichierBlast
if {[DecortiqueBlastPCDNA All All Numbers $FichierBlastP 20 7]==0} {return [list "No hits found"]}
Wup "20 7 means that we take from the 20 first access there first 7 hits only"
set Trouve 0
set LesDefinitions {}
set LesScores {}
#pour chaque proteine on cherche le hit de meilleur score
foreach BID [DecortiqueBlastPCDNA All All Numbers] {
if {[EstUnAccessPDB $BID]} {continue}
set Access [DecortiqueBlastPCDNA $BID All Access]
set ScoreBestHit 0
foreach Hit [DecortiqueBlastPCDNA $BID All Numbers] {
set E [DecortiqueBlastPCDNA $BID $Hit Expect]
if {[expr $E>1.e-3] && $E!=0.0} {continue}
set nGaps [DecortiqueBlastPCDNA $BID $Hit Gaps]
set nId [DecortiqueBlastPCDNA $BID $Hit Identites]
set Score($BID,$Hit) [expr $nId + $nGaps]
if {[expr [set Score($BID,$Hit)] > $ScoreBestHit] && [expr $nGaps<$nId] } {
set ScoreBestHit [set Score($BID,$Hit)]
set NumBestHit $Hit
}
}
if {$ScoreBestHit!=0 } {
lappend LesScores "$BID $Access $NumBestHit $ScoreBestHit"
}
}
#on regroupe les proteines de meme score
set LesSc {}
foreach Ligne $LesScores {
set Sc [lindex $Ligne end]
lappend LesSc $Sc
lappend LesProt($Sc) $Ligne
}
set LesScTries [lsort -integer -decreasing $LesSc]
foreach Sc $LesScTries {
#on parcourt les groupes jusqu'a en trouver un contenant une proteine humaine
foreach Prot [set LesProt($Sc)] {
set BanqueID [lindex $Prot 0]
set Access [lindex $Prot 1]
set LeEMBL [LaSequenceDesBanques $BanqueID $Access a "OnVeutNucEMBL"]
if {$LeEMBL!={}} {
set OS "Inconnu inconnu"
set LaDef {}
foreach Ligne $LeEMBL {
if {[regexp "^OS " $Ligne]} {
set Genre "Inconnu"
set Espece "inconnu"
scan $Ligne "%s %s %s" Bidon Genre Espece
set OS "$Genre $Espece"
regsub {\.$} $OS "" OS
continue
}
# on prend une def plus complete que celle de DecortiqueBlastPCDNA
if {[regexp "^DE " $Ligne]} {
regsub "^DE " $Ligne "" Ligne
set Ligne [string trim $Ligne]
lappend LaDef $Ligne
}
}
if {$LaDef!={}} { set DE [join $LaDef " "] }
set Humaine [regexp -nocase $Organisme $OS]
} else {
continue
}
if {$Humaine} {
set Trouve 1
lappend LesDefinitions "$BanqueID $Access $DE"
}
}
if {$Trouve} {break}
}
if {[llength $LesDefinitions] == 0} {
lappend LesDefinitions "No human protein with expect less than 1.e-3 in the BlastP results"
}
Espionne ""
return $LesDefinitions
}
proc DecortiqueSortieRepeatMasker {RepeatVoulu Quoi {Texte ""}} {
global DecortiqueSortieRepeatMasker
Wup "RepeatVoulu can be All or a number"
Wup "Quoi can be Numbers, nBases, Pourcent, Nature, Occurrences"
set LesRepeats {}
if { $Texte=="" } {
if {[info exists DecortiqueSortieRepeatMasker($RepeatVoulu,$Quoi)]} { return [set DecortiqueSortieRepeatMasker($RepeatVoulu,$Quoi)] }
return {}
} else {
if {[info exists DecortiqueSortieRepeatMasker]} { unset DecortiqueSortieRepeatMasker }
}
set OnAttendBasesMasked 1
set Repeat 0
foreach Ligne [split $Texte "\n"] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
if {$OnAttendBasesMasked} {
if { ! [regexp "bases masked" $Ligne]} { continue }
set OnAttendBasesMasked 0
regsub "bases masked:" $Ligne "" Ligne
regsub "bp" $Ligne "" Ligne
regsub {\(} $Ligne "" Ligne
regsub {\)} $Ligne "" Ligne
scan $Ligne "%d %f" nBasesMasquees PourcentMasque
set DecortiqueSortieRepeatMasker(All,nBases) $nBasesMasquees
set DecortiqueSortieRepeatMasker(All,Pourcent) $PourcentMasque
continue
}
if {[regexp "SINEs|LINEs|LTR elements|DNA elements|Total interspersed repeats" $Ligne]} { continue }
if {[regexp {\%} $Ligne]} {
if {[regexp "Small RNA" $Ligne] || [regexp "Simple repeats" $Ligne] || [regexp "Low complexity" $Ligne] } {
scan $Ligne "%s %s %d" TypeRepeat1 TypeRepeat2 nOccurrences
set TypeRepeat "$TypeRepeat1 $TypeRepeat2"
} else {
scan $Ligne "%s %d" TypeRepeat nOccurrences
}
if { $nOccurrences != 0 } {
regsub {\:} $TypeRepeat "" TypeRepeat
incr Repeat
set Nature($Repeat) $TypeRepeat
set Occurrences($Repeat) $nOccurrences
lappend LesRepeats "$Repeat"
}
continue
}
}
set DecortiqueSortieRepeatMasker(All,Numbers) $LesRepeats
foreach R $LesRepeats {
set DecortiqueSortieRepeatMasker($R,Nature) [set Nature($R)]
set DecortiqueSortieRepeatMasker($R,Occurrences) [set Occurrences($R)]
}
return [DecortiqueSortieRepeatMasker $RepeatVoulu $Quoi]
}
proc BlastPDeLaPreditePourTous {{NomATraiter ""}} {
global RepertoireDuGenome
global CommandeBlastPPourTous
global GardeToutBlastPPourTous
global TestExistenceBlastPPourTous
JeMeSignale
if {$NomATraiter == ""} {
set Liste [ListeDesPABs]
} else {
set Liste [list $NomATraiter]
}
set Repertoire "$RepertoireDuGenome/blastp"
if { ! [file exists "$Repertoire"]} {
File mkdir $Repertoire
}
if {[info exists CommandeBlastPPourTous]} {
set CommandeBlast $CommandeBlastPPourTous
if {[info exists GardeToutBlastPPourTous]} {
set GardeTout $GardeToutBlastPPourTous
} else {
setGardeTout 0
}
if {[info exists TestExistenceBlastPPourTous]} {
set TestExistence $TestExistenceBlastPPourTous
} else {
set TestExistence 1
}
} else {
set GardeTout 0
set TestExistence 1
set BlastPDataBase [LocaliseBlastPDataBase]
if {$BlastPDataBase==""} { return "" }
set CommandeBlast "blastall \
-p blastp \
-i \$FichierTFA \
-o \$FichierBlast \
-d $BlastPDataBase \
-v 500 \
-K 0 \
-b 300 \
-e 30.0 \
-F F"
#attention sur les consignes d'olivier j'ai enleve le filtre !!
if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
set CommandeBlast [Entre $CommandeBlast]
if {$CommandeBlast==""} { return "" }
}
while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
set TestExistence 1
set GardeTout 1
break
} elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
set TestExistence 0
set GardeTout 0
break
} elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
set TestExistence 1
set GardeTout 0
break
}
}
set CommandeBlastPPourTous $CommandeBlast
set GardeToutBlastPPourTous $GardeTout
set TestExistenceBlastPPourTous $TestExistence
}
foreach Boite $Liste {
set Nom [Box $Boite nom]
set FichierTFA "$RepertoireDuGenome/genscanpredictions/$Nom"
set FichierBlast "$Repertoire/$Nom"
Espionne "Je m'occupe de $Nom"
if { ! [file exists $FichierTFA]} {
Espionne "$FichierTFA does not exist"
InformeSansDemander $Nom "=BlastP: $FichierTFA does not exist."
continue
}
if {$GardeTout && [file exists $FichierBlast] } {
continue
}
if { $TestExistence && [file exists $FichierBlast] } {
if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
continue
}
}
Espionne "Je vais lancer BlastP sur $Nom"
InformeSansDemander $Nom "=BlastP: prediction genscan trouvee"
eval exec $CommandeBlast
}
}
proc LesLocalisationsSurChroContig NomVoulu {
global LesLocalisationsSurChroContig
global RepertoireDuGenome
JeMeSignale
if {[info exists LesLocalisationsSurChroContig($NomVoulu)]} {
return [set LesLocalisationsSurChroContig($NomVoulu)]
}
if {[info exists LesLocalisationsSurChroContig("EstCharge")]} {
return [set LesLocalisationsSurChroContig("EstCharge")]
}
set Fichier "$RepertoireDuGenome/fiches/localisationchrocontig"
if {[file exists $Fichier]} {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" Nom
regsub "$Nom " $Ligne "" Ligne
lappend LesLocalisationsSurChroContig($Nom) $Ligne
}
set LesLocalisationsSurChroContig("EstCharge") [list "No value"]
return [LesLocalisationsSurChroContig $NomVoulu]
}
if {$NomVoulu=="Create"} {
set Liste [ListeDesPABs]
set CreeFichier 1
} else {
set Liste [list $NomVoulu]
set CreeFichier 0
}
foreach Nom $Liste {
set LesHomologues [ChaqueSegmentDuBlastN $Nom]
set LesChroContig($Nom) {}
set OldChroContig ""
foreach Homologue $LesHomologues {
scan $Homologue "%s %s %s %s %s %f %d %d %d %d" ChroContigTroncon n1 n2 Orga PrctId E DQ FQ Deb Fin
if {[expr $E > 1.e-3] } { continue }
regsub {\:} $ChroContigTroncon " " ChroContigTroncon
regsub {_} $ChroContigTroncon " " ChroContigTroncon
set Troncon 0
scan $ChroContigTroncon "%s %s %s" Chro Contig Troncon
set Troncon [Base10 $Troncon]
regsub {^0} $Chro "" Chro
if {![info exists DejaVu($Nom,$Chro,$Contig)]} {
set DejaVu($Nom,$Chro,$Contig) 1
if {$Deb<$Fin} {
set MeilleureGauche($Nom,$Chro,$Contig) $Deb
set MeilleureDroite($Nom,$Chro,$Contig) $Fin
} else {
set MeilleureGauche($Nom,$Chro,$Contig) $Fin
set MeilleureDroite($Nom,$Chro,$Contig) $Deb
}
lappend LesNomChroContigDansLOrdre($Nom) "$Nom,$Chro,$Contig"
}
lappend LesHomologuesDe($Nom,$Chro,$Contig) $Homologue
}
if {[info exists DejaVu]} { unset DejaVu }
if { ! [info exists LesNomChroContigDansLOrdre($Nom)]} { continue }
foreach NCC [set LesNomChroContigDansLOrdre($Nom)] {
foreach Homologue [set LesHomologuesDe($NCC)] {
scan $Homologue "%s %s %s %s %s %f %d %d %d %d" ChroContigTroncon n1 n2 Orga PrctId E DQ FQ Deb Fin
regsub {\:} $ChroContigTroncon " " ChroContigTroncon
regsub {_} $ChroContigTroncon " " ChroContigTroncon
set Troncon 0
scan $ChroContigTroncon "%s %s %s" Chro Contig Troncon
set Troncon [Base10 $Troncon]
regsub {^0} $Chro "" Chro
if {![info exists DejaVu($Nom,$Chro,$Contig)]} {
lappend LesChroContig($Nom) "$Chro $Contig"
set DejaVu($Nom,$Chro,$Contig) 1
}
lappend LesPositions($Nom,$Chro,$Contig) $Deb $Fin
if {[expr $Deb < $Fin]} {
set Sens($Nom,$Chro,$Contig) "+"
} else {
set Sens($Nom,$Chro,$Contig) "-"
}
}
set LesLocas {}
foreach Loc [set LesChroContig($Nom)] {
scan $Loc "%s %s" Chro Contig
set LesPosTriees [lsort -integer [set LesPositions($Nom,$Chro,$Contig)]]
set MG [set MeilleureGauche($Nom,$Chro,$Contig)]
set iMG [lsearch $LesPosTriees $MG]
while 1 {
if {$iMG<=0} { break }
set NewMG [lindex $LesPosTriees [incr iMG -1]]
if {[expr $NewMG + 100000 < $MG]} { break }
set MG $NewMG
}
set MD [set MeilleureDroite($Nom,$Chro,$Contig)]
set iMD [lsearch $LesPosTriees $MD]
set L [expr [llength $LesPosTriees] -1]
while 1 {
if {$iMD>=$L} { break }
set NewMD [lindex $LesPosTriees [incr iMD 1]]
if {[expr $MD + 100000 < $NewMD]} { break }
set MD $NewMD
}
set Gauche $MG
set Droite $MD
set Orient [set Sens($Nom,$Chro,$Contig)]
Espionne "LesLocalisation sur $Nom $Chro $Contig $Gauche $Droite $Orient"
lappend LesLocas "$Chro $Contig $Gauche $Droite $Orient"
}
}
if {$CreeFichier} {
set LesLocalisationsSurChroContig($Nom) $LesLocas
foreach Lo $LesLocas {
AppendAuFichier $Fichier "$Nom $Lo"
}
} else {
return $LesLocas
}
set LesLocalisationsSurChroContig("EstCharge") [list "No value"]
}
if {$CreeFichier} { return $Fichier }
return [LesLocalisationsSurChroContig $NomVoulu]
}
proc CreeBornesDesCDNAs {{Qui ""} {Adjonction ""}} {
global RepertoireDuGenome
set FichierBornesDesPABs "[RepertoireDuGenome]/fiches/bornesdespabs"
if {[file exists $FichierBornesDesPABs]} { Garde $FichierBornesDesPABs }
set DebutBornes 101
set FinBornes $DebutBornes
set NumDuDernier 0
if {$Adjonction=="EnFin"} {
set Adjonction 1
set AdjonctionEnFin 1
set LesBornesDesPABs [LesLignesDuFichier $FichierBornesDesPABs]
} else {
set Adjonction 0
set AdjonctionEnFin 0
set LesBornesDesPABs {}
}
if {$AdjonctionEnFin} {
set DernierPos [DernierPAB "EnPosition"]
set F [Box $DernierPos fin]
set DebutBornes [expr $F + 1000]
set FinBornes $DebutBornes
set DernierNum [DernierPAB "EnNumero"]
regsub "^[PreFixe]" $DernierNum "" NumDuDernier
set NumDuDernier [Base10 $NumDuDernier]
set NouveauNum [expr $NumDuDernier + 1]
set NouveauNom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $NouveauNum]
if { ! [OuiOuNon "Ok to add the new elements \n\
at $DebutBornes after $DernierPos \n\
Numbering starts with $NouveauNom"]} { return "" }
if { ! [OuiOuNon "I'll replace $FichierBornesDesPABs and exit.\nOK ?"]} { return "" }
}
set OS [Entre "Homo sapiens"]
set OC [OCduOS $OS]
if { ! [file exists "$RepertoireDuGenome/nuctfa"]} { File mkdir "$RepertoireDuGenome/nuctfa" }
if { ! [file exists "$RepertoireDuGenome/nucembl"]} { File mkdir "$RepertoireDuGenome/nucembl" }
set PrenomNom(cDNA_with_owner_clone) "cDNAs with owner and clone"
set PrenomNom(Affymetrix) "Affymetrix"
set PrenomNom(In_TFA) "Nucleic sequences in one TFA file"
set PrenomNom(In_TFA_WithCC) "Nucleic sequences in one TFA file with CC and Owner"
set PrenomNom(In_TFA_FromEstChip) "Nucleic sequences in one TFA file with xxx_yyy and definition"
set PrenomNom(DNA_with_Access_Alias) "file with a 'access (alias (def))' list"
if {$Qui==""} {
set LesQui [array names PrenomNom]
foreach Q $LesQui {
lappend LesPNoms [set PrenomNom($Q)]
}
set Qui [ChoixParmiJoli $LesQui {} $LesPNoms]
if {$Qui==""} { exit }
}
if {$Qui=="DNA_with_Access_Alias"} {
if { ! [OuiOuNon "Could You browse for a file with 'access (alias (def))' ?"]} {
return [CreeBornesDesCDNAs]
}
set FichierAccessAlias [ButineArborescence "All" $RepertoireDuGenome]
if {$FichierAccessAlias==""} { return [CreeBornesDesCDNAs] }
set Debut $DebutBornes
set Fin $Debut
set Long 1000
set n $NumDuDernier
foreach Ligne [LesLignesDuFichier $FichierAccessAlias] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
set Alias [format "%s%[FormatDesNumerosPourCollection]" "ALIAS_" $n]
scan $Ligne "%s %s" Access Alias
regsub "$Alias +$Access +" $Ligne "" Descr
set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
set Debut [expr $Debut + $Offset]
set Fin [expr $Debut + $Long -1]
set Orient "F"
incr n
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNucEMBL"]
if {$LesLignesEMBL==""} {
AppendAuFichier "$RepertoireDuGenome/not_founded_accesses" $Access
continue
}
set DE ""
set LesNouvellesLignes {}
foreach Ligne $LesLignesEMBL {
if {[regexp "^ID " $Ligne]} {
scan $Ligne "%s %s" Bidon ID
set Ligne "ID $Nom created by Gscope from ID $ID"
}
if {[regexp "^AC " $Ligne]} {
scan $Ligne "%s %s" Bidon AC
set Ligne "AC $Nom;"
}
if {[regexp "^DE " $Ligne]} {
regsub {DE *} $Ligne "" DE
}
if {[regexp "^SQ " $Ligne]} {
lappend LesNouvellesLignes "CC Original description: $Descr"
}
lappend LesNouvellesLignes $Ligne
}
set Entete "$Nom $Access $Alias : $Descr"
Espionne $Entete
set NucEMBL [join $LesNouvellesLignes "\n"]
set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
Sauve $NucTFA dans $FichierNucTFA
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
}
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
}
}
set FromEstChip 0
set WithCC 0
set IExpect "(I expect '>access definition ...')"
if {$Qui=="In_TFA_WithCC"} {
set WithCC 1
set Qui "In_TFA"
set IExpect "(I expect '>CodeClone Owner')"
}
if {$Qui=="In_TFA_FromEstChip"} {
set FromEstChip 1
set Qui "In_TFA"
set IExpect "(I expect '>xxx_yyy definition')"
}
if {$Qui=="In_TFA"} {
if { ! [OuiOuNon "Could You browse a TFA file with all sequences ? \n $IExpect"]} {
return [CreeBornesDesCDNAs]
}
set FichierTFAs [ButineArborescence "All" $RepertoireDuGenome]
if {$FichierTFAs==""} { return [CreeBornesDesCDNAs] }
set Debut $DebutBornes
set Fin $Debut
set Long 1000
set n $NumDuDernier
foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess"] {
set LesLignesEMBL {}
set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
set Descr [EnteteDuTexteTFA $TFA]
set Seq [QueLaSequenceDuTexteTFA $TFA]
regsub ">" $Descr "" Descr
if {$FromEstChip} { scan $Descr "%s" CC ; regsub "$CC " $Descr "" Descr }
if {$WithCC} { scan $Descr "%s %s" CC Owner }
regsub -all -nocase {[^a-z]} $Seq "" Seq
set LongSeq [string length $Seq]
set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
set Debut [expr $Debut + $Offset]
set Fin [expr $Debut + $Long -1]
set Orient "F"
incr n
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $Nom created by Gscope from a tfas file "
lappend LesLignesEMBL "AC $Nom;"
if {$WithCC} {
lappend LesLignesEMBL "CC CodeClone $CC Owner $Owner"
set Entete "$Nom $CC $Owner"
} elseif {$FromEstChip} {
lappend LesLignesEMBL "CC CodeClone $CC"
lappend LesLignesEMBL "CC Description $Descr"
set Entete "$Nom $CC $Descr"
} else {
set Sep ":"
foreach Wrap [WrapLeTexte $Descr 50] {
lappend LesLignesEMBL "CC Original description$Sep $Wrap"
set Sep "+"
}
set Entete "$Nom : $Descr"
}
set SeqEMBL [QueSequenceFormatEMBL $Seq "AvecSQ"]
lappend LesLignesEMBL $SeqEMBL
set NucEMBL [join $LesLignesEMBL "\n"]
set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
Sauve $NucTFA dans $FichierNucTFA
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
}
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
}
}
if {$Qui=="Affymetrix"} {
if { ! [OuiOuNon "Could You browse a file with Affymetrix Clone Accession numbers ? \n\
(I expect 'Clone Access Definition ...')"]} {
return [CreeBornesDesCDNAs]
}
set FichierAffy [ButineArborescence "All" $RepertoireDuGenome]
if {$FichierAffy==""} { return [CreeBornesDesCDNAs] }
set Debut $DebutBornes
set Fin $Debut
set Long 500
set n $NumDuDernier
foreach CcAcDescr [LesLignesDuFichier $FichierAffy] {
if { ! [regexp -nocase {[a-z]} $CcAcDescr]} { continue }
scan $CcAcDescr "%s %s" Alias Access
regsub "$Alias +$Access +" $CcAcDescr "" Descr
set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
set Debut [expr $Debut + $Offset]
set Fin [expr $Debut + $Long -1]
set Orient "F"
incr n
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNucEMBL"]
if {$LesLignesEMBL==""} {
AppendAuFichier "$RepertoireDuGenome/not_founded_accesses" $Access
continue
}
set DE ""
set LesNouvellesLignes {}
foreach Ligne $LesLignesEMBL {
if {[regexp "^ID " $Ligne]} {
scan $Ligne "%s %s" Bidon ID
set Ligne "ID $Nom created by Gscope from ID $ID"
}
if {[regexp "^AC " $Ligne]} {
scan $Ligne "%s %s" Bidon AC
set Ligne "AC $Nom;"
}
if {[regexp "^DE " $Ligne]} {
regsub {DE *} $Ligne "" DE
}
if {[regexp "^SQ " $Ligne]} {
lappend LesNouvellesLignes "CC Affy's description: $Descr"
}
lappend LesNouvellesLignes $Ligne
}
set Entete "$Nom $Access $Alias : $Descr"
Espionne $Entete
set NucEMBL [join $LesNouvellesLignes "\n"]
set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
Sauve $NucTFA dans $FichierNucTFA
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
}
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
}
}
if {$Qui=="cDNA_with_owner_clone"} {
foreach Fichier [glob "$RepertoireDuGenome/cdna/*"] {
set LeTFA [LesLignesDuFichier $Fichier]
set Entete [lindex $LeTFA 0]
set LaSeq [lrange $LeTFA 1 end]
scan $Entete "%s %s" ChevronUser Clone
regsub "$ChevronUser $Clone" $Entete "" Remarque
set Remarque [string trim $Remarque]
regsub ">" $ChevronUser "" User
set CDNAcode "$User$Clone"
set Seq [join $LaSeq ""]
set NomFiCDNA [file tail $Fichier]
set JR [JumeauRepresentatif $NomFiCDNA]
if {$JR!=$NomFiCDNA && $JR!=""} { append Remarque "SameSeqAs:$JR" }
set NomDuFichierCDNA($CDNAcode) $NomFiCDNA
set Clones($CDNAcode) $Clone
set Seqs($CDNAcode) $Seq
set Remarques($CDNAcode) $Remarque
set Users($CDNAcode) $User
lappend LesCDNAs $CDNAcode
}
set LesCDNAs [lsort $LesCDNAs]
set Debut $DebutBornes
set Fin $Debut
set n $NumDuDernier
foreach CDNA $LesCDNAs {
incr n
set Seq [set Seqs($CDNA)]
set Clone [set Clones($CDNA)]
set Rem [set Remarques($CDNA)]
set User [set Users($CDNA)]
set NomFiCDNA [set NomDuFichierCDNA($CDNA)]
set Long [string length $Seq]
set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
set Debut [expr $Debut + $Offset]
set Fin [expr $Debut + $Long -1]
set Orient "F"
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set PABduFiCDNA($NomFiCDNA) $Nom
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
if {[regexp "SameSeqAs:" $Rem]} {
set JR [StringApres "SameSeqAs:" dans $Rem]
append Rem " [set PABduFiCDNA($JR)]"
}
set NucTFA [SequenceFormatTFA $Seq "$Nom $Clone $User $Rem" "nucbrut"]
set NucEMBL ""
append NucEMBL "ID $Nom PRELIMINARY; DNA; $Long bases."
append NucEMBL "\nAC $Nom"
append NucEMBL "\nOS $OS."
append NucEMBL "\nOC $OC"
append NucEMBL "\nCC -!- cDNA sequence by [set PrenomNom($Qui)]"
append NucEMBL "\nCC User $User Clone $Clone"
if {$Rem!=""} { append NucEMBL "\nCC $Rem" }
append NucEMBL "\n[QueSequenceFormatEMBL $Seq AvecSQ]"
Sauve $NucTFA dans "$RepertoireDuGenome/nuctfa/$Nom"
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
}
}
if {$Adjonction} { exit }
InformeIdentitesDuCDNAPourTous
return $LesBornesDesPABs
}
proc ShowHTMLBox {K Action} {
global ShowHTMLBox
JeMeSignale
set Id [$K find withtag current]
if {$Action=="Enter"} {
if {[info exists ShowHTMLBox($K,Image)]} { $K raise [set ShowHTMLBox($K,Image)] }
set LesTags [$K gettags $Id]
set Alias [lindex $LesTags 0]
set Nom [NomDuAlias $Alias]
if {$Nom!=""} {
return [FetcheBox $K $Nom $Nom]
} else {
return [RepereBox $Alias]
}
}
if {$Action=="Press"} {
$K lower $Id
set ShowHTMLBox($K,Image) $Id
return
}
if {$Action=="Release"} {
if {[info exists ShowHTMLBox($K,Image)]} { $K raise [set ShowHTMLBox($K,Image)] }
}
}
proc MapCliquable {{Action "Create"} {Repertoire ""}} {
global RepertoireDuGenome
global LesOrdresPourGIF
Gs "Canvas"
if {$Repertoire==""} { set Repertoire "$RepertoireDuGenome/maps" }
set LesFichierSize [glob -nocomplain "$Repertoire/*.size"]
if {$Action=="Existe"} { return [llength $LesFichierSize] }
set Titre [PreFixe]
if {$Action=="PourGif"} {
set PourGif 1
set Image NeRienFaire
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set LesOrdresPourGif {}
set w "PourGif"
set K "OrdrePourGif"
} else {
set PourGif 0
set Image image
set Canvas canvas
set Bind bind
set Pack pack
set Fram frame
set Button button
set Scrollbar scrollbar
set Grid grid
set FonctionRejetteLaBoite "NeRejettePasLaBoite"
set w [NomDe board]
catch {destroy $w}
toplevel $w
wm title $w "$Titre"
wm iconname $w "$Titre"
set K $w.canvas
}
if {[llength $LesFichierSize]>1} {
set FichierSize [ChoixParmi $LesFichierSize]
if {$FichierSize==""} { return {} }
} else {
set FichierSize [lindex $LesFichierSize 0]
}
regsub ".size$" $FichierSize ".gif" FichierImage
regsub ".size$" $FichierSize ".html" FichierHTML
scan [PremiereLigneDuFichier $FichierSize] "%d %d" Largeur Hauteur
if {$PourGif} {
} else {
set K [UnCanva $Largeur $Hauteur]
}
$Image create photo FondDeMap -file $FichierImage
foreach Aire [LesAiresCliquablesDuHTML $FichierHTML] {
scan $Aire "%s %d %d %d %d %s" AliasLu xMin yMin xMax yMax Ref
if {$PourGif} {
set LesTags [list ]
} else {
set LesTags [list $AliasLu "ClickMe"]
}
$K create rectangle $xMin $yMin $xMax $yMax -fill red -tags $LesTags
}
$K bind "ClickMe" <Enter> "ShowHTMLBox $K Enter"
$K bind "ClickMe" <Leave> "ShowHTMLBox $K Leave"
$K create image 0 0 -image FondDeMap -anchor "nw" -tags [list Image]
$K bind "Image" <1> "ShowHTMLBox $K Press"
if {$PourGif} {
return $LesOrdresPourGIF
} else {
return $K
}
}
proc LesAiresCliquablesDuHTML {{FichierHTML ""}} {
global RepertoireDuGenome
if {$FichierHTML==""} {
set FichierHTML [ButineArborescence "All"]
if {$FichierHTML==""} { return {} }
}
set Texte [ContenuDuFichier $FichierHTML]
set Map [ValeurDeLaBalise "map" Texte]
while {$Map!=""} {
set Area [ValeurDeLaBalise "area" Map]
if {$Area==""} { break }
set Reference [StringApres "href=" dans $Area]
regsub -all {\"} $Reference "" Reference
set Nom [file tail $Reference]
regsub -nocase {(.htm|.html)$} $Nom "" Nom
set Shape [StringApres "shape=" dans $Area]
set TexteCoords [StringSuivant "coords=" dans $Area]
regsub -all {[\"\,]} $TexteCoords " " TexteCoords
if {[regexp "circle" $Shape]} {
scan $TexteCoords "%d %d %d" xC yC rC
set xMin [expr $xC-$rC]
set xMax [expr $xC+$rC]
set yMin [expr $yC-$rC]
set yMax [expr $yC+$rC]
} else {
scan $TexteCoords "%d %d %d %d" xMin yMin xMax yMax
}
lappend LesAires "$Nom $xMin $yMin $xMax $yMax $Reference"
}
return $LesAires
}
proc CreeAccessAliasDefinitionPourPeroxNew {} {
global RepertoireDuGenome
foreach {a b c} [LesLignesDuFichier "$RepertoireDuGenome/DeAurora/perox20010503ok.txt"] {
set Alias ""
set Access ""
scan $a "%s" Alias
set DE [string trim $b]
scan $c "%s" Access
if {$Alias=="" || $DE=="" || $Access==""} { break }
lappend Sortie "$Access $Alias $DE"
set LSDB [LaSequenceDesBanques $Access $Access a "OnVeutEMBL"]
if {$LSDB=={}} {
FaireLire "$a $b $c\nI couldn't get the sequence $Access"
}
}
Espionne [SauveLesLignes $Sortie dans "$RepertoireDuGenome/PeroxAccesAliasDef.fof"]
exit
}
proc NarcisseDuAliasPourTous {} {
global RepertoireDuGenome
global NarcisseDuAlias
ChargeNarcisseDuAlias
set FichierNarcisse "$RepertoireDuGenome/fiches/narcisse"
if {[info exists NarcisseDuAlias] && ! [file exists $FichierNarcisse]} {
if {[OuiOuNon "Can I use NarcisseDuAlias to create Narcisse ?"]} {
set LesNarcisses {}
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
if {[info exists NarcisseDuAlias($Alias)]} {
set NdA [set NarcisseDuAlias($Alias)]
set Narcisse($Nom) $NdA
lappend LesNarcisses "$Nom $NdA"
}
}
if {$LesNarcisses!={}} {
SauveLesLignes $LesNarcisses dans $FichierNarcisse
}
}
}
}
proc InformeValiGNParAlias {} {
foreach Nom [ListeDesPABs] {
set ValiGN [ExtraitInfo $Nom "ValiGN"]
if {$ValiGN!=""} { continue }
set Alias [Alias $Nom]
if {$Alias==""} { continue }
InformeSansDemander $Nom "=ValiGN: $Alias"
}
}
proc InformeParChangementEnteteDuChamp {Ancien Nouveau} {
foreach Nom [ListeDesPABs] {
set Valeur [ExtraitInfo $Nom $Ancien]
if {$Valeur==""} { continue }
Espionne "$Nom $Nouveau: $Valeur"
InformeParSuppressionDuChamp $Nom $Ancien
InformeSansDemander $Nom "$Nouveau: $Valeur"
}
}
proc VerifieLesPDBs {} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/lespdbs"] {
regsub ">" $Ligne "" Ligne
ScanLaListe [split $Ligne ":"] Nom aPDB
set SeqBanque [LaSequenceDuTFAs "/blast/pdb" $aPDB]
set SeqPerox [LaSequenceDuTFAs "$RepertoireDuGenome/tfasdescopains/$Nom" $aPDB]
set SeqBanque [join [lrange [split $SeqBanque "\n"] 1 end] ""]
set SeqPerox [join [lrange [split $SeqPerox "\n"] 1 end] ""]
if {$SeqBanque==$SeqPerox} {
continue
}
Espionne "$Nom $aPDB"
Espionne "$SeqBanque\n$SeqPerox"
FaireLire "$Nom $aPDB"
lappend LesMauvais $Nom
}
SauveLesLignes $LesMauvais dans "$RepertoireDuGenome/lesmauvais"
exit
}
proc BlastPPourCollection Nom {
Wup "Attention we call the BlastPPourTous for only one !!"
BlastPPourTous $Nom
}
proc MSFPourCollection Nom {
Wup "Attention we call the DbClustalPourTous for only one !!"
DbClustalPourTous $Nom
}
proc CreeProteomeAvecUneListeAccessAliasDefinition {Fichier {AADorBAAD ""}} {
global RepertoireDuGenome
global NarcisseDuAlias
set Geno [file tail $RepertoireDuGenome]
set FichierFOF "$RepertoireDuGenome/$Geno.fof"
set RepProteome "$RepertoireDuGenome/proteome"
if { ! [file exists $RepProteome]} {
File mkdir $RepProteome
}
if {[glob -nocomplain "$RepProteome/*"]=={}} {
set LaTotale 1
} else {
set LaTotale [OuiOuNon "Do I replace all known files ? "]
}
set TesteTout 0
set AppendSeul 0
while {[file exists $FichierFOF]} {
set LaTotale 0
if {[OuiOuNon "$FichierFOF already exists. \nDo I keep it, doing nothing ?" 0]} { return $FichierFOF }
if {[OuiOuNon "$FichierFOF already exists. \nDo I replace all existing files ?" 0]} {
set LaTotale 1
break
}
if {[OuiOuNon "$FichierFOF already exists. \nDo I test for changes ?"]} {
set TesteTout 1
break
}
}
if {$TesteTout} {
foreach Ligne [LesLignesDuFichier $FichierFOF] {
scan $Ligne "%s %s" Alias Ver
set VerDuAlias($Alias) $Ver
}
}
if {$AADorBAAD==""} {
if { [OuiOuNonMemo "Does this file contain BanqueId AND Access (Alias (Definition)) ?" 0] } {
set AADorBAAD "BAAD"
} else {
set AADorBAAD "AAD"
}
}
set BanqueIdAndAccess [string compare -nocase $AADorBAAD "BAAD"]
set n 0
foreach Ligne [LesLignesDuFichier $Fichier] {
incr n
if { ! [regexp -nocase {[a-z]+} $Ligne]} { continue }
if {[regexp -nocase {^[ \t]*\#} $Ligne]} { continue }
regsub -all "\t" $Ligne " " Ligne
set BanqueId ""
set Access ""
set Alias "ALIAS_$n"
set DE ""
if {$BanqueIdAndAccess} {
scan $Ligne "%s %s %s" BanqueId Access Alias
regsub "\:" $BanqueId "\\:" BanqueIdSansPP
regsub " *$BanqueIdSansPP +$Access +$Alias +" $Ligne "" DE
} else {
scan $Ligne "%s %s" Access Alias
regsub " *$Access +$Alias +" $Ligne "" DE
}
if {$Access==""} { set Access $BanqueId }
Espionne "$BanqueId $Access $Alias $DE"
if {$TesteTout && [info exists VerDuAlias($Alias)]} {
set Ver [set VerDuAlias($Alias)]
if {[regexp "/" $Access]} {
set RepAccess $Access
} else {
set RepAccess "$RepProteome/$Access"
}
while {$RepAccess!=$Ver} {
FaireLire " Reading the line \n \
$Ligne \n \
I see that \n\
$Alias $RepAccess \n \
doesn't correspond to the old \n\
$Alias $Ver"
if {[OuiOuNon "Do I ignore this, and use $Access ?"]} { break }
if {[OuiOuNon "Do I use the old access $Ver ?"]} { set Access [file tail $Ver] }
if {[OuiOuNon "Do I cancel creation of $FichierFOF ?"]} { return "" }
}
}
set FichierEMBL "$RepProteome/[file tail $Access]"
regsub {\.tfa$} $FichierEMBL "" FichierEMBL
set AccessOK $Access
if { $LaTotale || ! [file exists $FichierEMBL]} {
if {[regexp {^https?:} $Access]} {
set LesLignesEMBL [LesLignesDuFichier $Access]
} else {
set AccessOK "NotYetAvailable"
set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"]
}
while {$LesLignesEMBL=={}} {
if {[file exists $FichierEMBL]} {
set LesLignesEMBL [LesLignesDuFichier $FichierEMBL]
break
}
if {[OuiOuNon "I didn't found the sequence $Access. Do I do it later ?"]} {
set DoItLater 1
break
}
if {[OuiOuNon "I didn't found the sequence $Access. Do I skipp ?"]} {
set DoItLater 0
break
}
if {[OuiOuNon "I didn't found the sequence $Access. Do I cancel ?"]} { return "" }
if {[OuiOuNon "I didn't found the sequence $Access. Do I stop ?"]} { exit }
}
if {$LesLignesEMBL!={}} {
SauveLesLignes $LesLignesEMBL dans $FichierEMBL
} else {
if {$DoItLater} {
set $FichierEMBL "xx"
} else {
continue
}
}
}
lappend LesFOFs "$Alias $FichierEMBL"
set NarcisseDuAlias($Alias) $AccessOK
}
return [SauveLesLignes $LesFOFs dans $FichierFOF]
}
proc QuelsCopainsDisponibles {} {
global RepertoireDuGenome
set LesRepertoiresCopains [glob -nocomplain $RepertoireDuGenome/co*]
foreach Copain $LesRepertoiresCopains {
lappend LesCopainsDisponibles [file tail $Copain]
}
return $LesCopainsDisponibles
}
proc MaquillePourTous {{LaListeMerci ""}} {
global RepertoireDuGenome
global Maquille
global MaquilleNon
if {[info exists MaquilleNon] && $MaquilleNon} { return {} }
set Maquillage "$RepertoireDuGenome/fiches/maquillage"
if {[file exists $Maquillage]} {
foreach Ligne [LesLignesDuFichier $Maquillage] {
scan $Ligne "%s %s" O N
set Maquille($O) $N
set Maquille($N) $O
}
}
if { ! [info exist Maquille]} {
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set OldMSF "$RepertoireDuGenome/DeBayroch/Familles/$Alias/$Alias.msf"
set NewMSF "$RepertoireDuGenome/msf/$Nom"
set OnAttend 1
if { ! [file exists $OldMSF]} { continue }
foreach OldLigne [LesLignesDuFichier $OldMSF] NewLigne [LesLignesDuFichier $NewMSF] {
if { ! [regexp "Name:" $OldLigne]} {
if {$OnAttend} { continue } else { break }
}
set OnAttend 0
scan $OldLigne "%s %s" Name OldNom
scan $NewLigne "%s %s" Name NewNom
if {[info exists Maquille($OldNom)]} {
FaireLire "$Nom $Alias $OldNom $NewNom"
}
set Maquille($OldNom) $NewNom
lappend LeMaquillage "$OldNom $NewNom"
set Maquille($NewNom) $OldNom
}
}
SauveLesLignes $LeMaquillage dans $Maquillage
}
if {$LaListeMerci!=""} { return [LesLignesDuFichier $Maquillage] }
return
}
proc Maquille Nom {
global Maquille
global MaquilleNon
if {[info exists MaquilleNon] && $MaquilleNon} { return $Nom }
if { ! [info exists Maquille]} { MaquillePourTous }
if { ! [info exists Maquille($Nom)]} { return $Nom }
return [set Maquille($Nom)]
}
proc Family Nom {
return [ExtraitInfo $Nom "Family"]
}
proc ComplementInfoPourTous {} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/Fam.txt"] {
scan $Ligne "%s %s" Alias Autre
set Alias [string toupper $Alias]
set MaLigne($Alias) $Ligne
if { ! [regexp {\(} $Autre]} { set Autre "" }
Espionne "$Alias $Autre."
regsub -all {[\(\)]} $Autre "" MonAutre($Alias)
set Reste [string range $Ligne 26 35]
set BAE ""
if {[regexp "P" $Reste]} { append BAE "B" } else { append BAE "b" }
if {[regexp "A" $Reste]} { append BAE "A" } else { append BAE "a" }
if {[regexp "E" $Reste]} { append BAE "E" } else { append BAE "e" }
set MonBAE($Alias) $BAE
}
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set Autre [set MonAutre($Alias)]
if {$Autre!=""} { set Autre "/$Autre" }
InformeSansDemander $Nom "ValiGN: $Alias$Autre\nFamily: [set MaLigne($Alias)]\nBAE: [set MonBAE($Alias)]"
}
}
proc AliasPourTous {} {
global RepertoireDuGenome
FaireLire "Please browse for the file .fof containing 'Alias ... ... ...'"
set FOF [ButineArborescence "All" "$RepertoireDuGenome"]
set Numero 0
foreach Ligne [LesLignesDuFichier $FOF] {
if { ! [regexp -nocase {[A-Z0-9_]} $Ligne]} { continue }
catch {unset Nom}
catch {unset Ver}
catch {unset OrigineBlastP}
catch {unset OrigineBallast}
catch {unset OrigineMSF}
set NbLus [scan $Ligne "%s %s %s %s %s %s" Alias OrigineVer OrigineBlastP OrigineBallast OrigineMSF SecondMSF]
if {$NbLus < 2} {
if {[OuiOuNon "$Ligne\n missing values. Do I stop ?"]} { exit }
continue
}
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] [incr Numero]]
InformeSansDemander $Nom "=Alias: $Alias"
}
}
proc LaListeNomAlias {} {
set LaListe {}
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
if {$Alias==""} { set Alias "unknown" }
lappend LaListe "$Nom $Alias"
}
return [join $LaListe "\n"]
}
proc LesAliasExistants {} {
return [NomDuAlias "LesAlias"]
}
proc NomDuAlias Alias {
global NomDuAlias
set ALIAS [string toupper $Alias]
if {[info exists NomDuAlias($Alias)]} { return [set NomDuAlias($Alias)] }
if {[info exists NomDuAlias($ALIAS)]} { return [set NomDuAlias($ALIAS)] }
if {[info exists NomDuAlias("EstCharge")]} { return "" }
set NomDuAlias("EstCharge") 1
set LesAlias {}
foreach Nom [ListeDesPABs] {
set AliasLu [Alias $Nom]
set ALIASLU [string toupper $AliasLu]
if {$AliasLu==""} { continue }
lappend LesAlias $AliasLu
lappend NomDuAlias($AliasLu) $Nom
if {$ALIASLU!=$AliasLu} { lappend NomDuAlias($ALIASLU) $Nom }
}
set NomDuAlias(LESALIAS) [lsort -unique $LesAlias]
return [NomDuAlias $Alias]
}
proc Alias Nom {
return [ExtraitInfo $Nom "Alias"]
}
proc FormatDesNumerosPourCollection {{OrfNumbering ""}} {
global RepertoireDuGenome
global FormatDesNumerosPourCollection
if {$OrfNumbering!="" && [info exists FormatDesNumerosPourCollection]} { unset FormatDesNumerosPourCollection }
if {[info exists FormatDesNumerosPourCollection]} { return $FormatDesNumerosPourCollection }
set Fichier "$RepertoireDuGenome/fiches/format_orf_numbering"
if {[file exists $Fichier]} {
scan [ContenuDuFichier $Fichier] "%s" FormatDesNumerosPourCollection
return $FormatDesNumerosPourCollection
}
set FormatDesNumerosPourCollection ""
while {$FormatDesNumerosPourCollection==""} {
if {$OrfNumbering==""} {
FaireLire "Howmany digits do we use for ORF numbering ? \n(1 from 1 to 9, 2 from 01 to 99, 3 from 001 to 999, etc.)"
set N [Entre 3]
} else {
set N $OrfNumbering
}
if {[regexp {^[1-9]+$} $N]} { break }
if {$OrfNumbering!=""} { FaireLire "Illegal OrfNumbering $OrfNumbering. I'll ask you for a correct value." }
set OrfNumbering ""
}
set FormatDesNumerosPourCollection "$N.${N}d"
Sauve $FormatDesNumerosPourCollection dans $Fichier
return $FormatDesNumerosPourCollection
}
proc AfficheLesSortiesDuBallast {FichierBlastP {Quoi "rsf"}} {
regsub {/co[a-z]+/} $FichierBlastP "/coballast/" FichiersBallast
regsub -nocase {\.[a-z_]*$} $FichiersBallast "" FichiersBallast
set Fichier "$FichiersBallast.$Quoi"
Espionne $Fichier
if { ! [file exists $Fichier]} { return "" }
return [AfficheFichier $Fichier "Avec$Quoi"]
}
proc InformeLesCopainsDeThetase {{Liste {}}} {
global RepertoireDuGenome
global InformeSansDemander
set InformeSansDemander 1
if {$Liste=={}} { set Liste [ListeDesPABs] }
foreach Nom $Liste {
foreach FichierCopain [glob -nocomplain "$RepertoireDuGenome/copains/$Nom/*"] {
set Access [file tail $FichierCopain]
set LesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"]
if {$LesEMBL=={}} {
InformeLeCopain "$Nom/$Access" "=AltAccess: not found"
continue
}
set SeqCopain [LaSequenceDesLignesEMBL [LesLignesDuFichier $FichierCopain]]
set SeqBanque [LaSequenceDesLignesEMBL $LesEMBL]
if {[string equal -nocase $SeqCopain $SeqBanque] || \
[string equal -nocase [string range $SeqCopain 1 end] $SeqBanque]} {
InformeLeCopain "$Nom/$Access" "=AltAccess: $AccessOK"
} else {
InformeLeCopain "$Nom/$Access" "=AltAccess: $AccessOK but with no identical sequence"
}
}
}
}
proc InformeLeCopainSansDemander {NomAccess {Append ""}} {
global InformeSansDemander
if {[info exists InformeSansDemander]} { set Memo $InformeSansDemander }
set InformeSansDemander 1
set Retour [InformeLeCopain $NomAccess $Append]
if {[info exists Memo]} { set InformeSansDemander $Memo }
return $Retour
}
proc InformeLeCopain {NomAccess {Append ""}} {
global RepertoireDuGenome
global FenetreInfoOuverte
global InformeSansDemander
set Access [file tail $NomAccess]
set Nom [file tail [file dirname $NomAccess]]
set FichierInfo "$RepertoireDuGenome/coinfos/$Nom/$Access"
if {[info exists FenetreInfoOuverte($Nom,$Access)]} {
raise [set FenetreInfoOuverte($Nom,$Access)]
if {$Append == ""} { return "[ContenuDuFichier $FichierInfo]" }
if {[OuiOuNon "$Append\n doit etre rajoute a la page info $Nom/$Access\n \
La page info est deja ouverte.\n \
Dois-je abandonner ?"]} { return -1 }
if {[OuiOuNon "Dois-je le faire maintenant ?"]} {
[set FenetreInfoOuverte($Nom,$Access)].text insert end "$Append\n"
return -2
}
FaireLire "Vous ferez, plus tard, le couper-coller pour moi. Merci."
return -3
}
set FenetreInfoOuverte($Nom,$Access) "$Nom,$Access"
if {! [file exists $FichierInfo]} {
set Information "Nom: $Nom $Access"
if {[file exists "$RepertoireDuGenome/beton/infocopainmodele"]} {
append Information "\n[ContenuDuFichier $RepertoireDuGenome/beton/infocopainmodele]"
}
Sauve $Information dans $FichierInfo
}
if { [info exists InformeSansDemander] && $InformeSansDemander } {
set BonTexte "[ContenuDuFichier $FichierInfo]\n$Append"
} else {
set BonTexte [EntreTexte "[ContenuDuFichier $FichierInfo]\n$Append"]
}
if { $BonTexte != "" } {
set TexteOk [Censure "$BonTexte"]
Sauve $TexteOk dans $FichierInfo
}
unset FenetreInfoOuverte($Nom,$Access)
return $BonTexte
}
proc VerifieLesNarcissesDesMutants {} {
foreach Nom [ListeDesPABs] {
if { ! [EstUnPABMute $Nom]} { continue }
set GF [GrandFrereDuMutant $Nom]
if {$GF==""} { FaireLire "$Nom has no GrandFrere" ; continue }
if {[Narcisse $GF]==[Narcisse $Nom]} { continue }
FaireLire "$Nom [Narcisse $Nom] is not [Narcisse $GF] of $GF"
}
}
proc NarcisseDansLOrdreDesPABs {} {
set FichierNarcisse "[RepertoireDuGenome]/fiches/narcisse"
foreach Ligne [LesLignesDuFichier $FichierNarcisse] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s" NomLu
if {[info exists SaLigne($NomLu)]} {
FaireLire "I already saw $NomLu\n\
$SaLigne($NomLu)\n\and now\n$Ligne\n\nI'll cancel"
return ""
}
set SaLigne($NomLu) $Ligne
}
set LeNouveau {}
foreach Nom [ListeDesPABs] {
if {[info exists SaLigne($Nom)]} { lappend LeNouveau $SaLigne($Nom) }
}
EspionneL $LeNouveau
if { ! [OuiOuNon "Do I save in $FichierNarcisse ?"]} { return "" }
return [SauveLesLignes $LeNouveau dans $FichierNarcisse]
}
proc LesPABsDansLOrdre {{Replace ""}} {
global RepertoireDuGenome
global ListeDesPABs
global ListeDeBoites
set ReplaceList [regexp -nocase "ReplaceList" $Replace]
set ReplaceFile [regexp -nocase "ReplaceFile" $Replace]
foreach Boite [ListeDesPABs] {
set Nom [Box $Boite nom]
set Debut [Box $Boite debut]
lappend AQuiEstCeDebut($Debut) $Nom
set AQuiEstCeDebut($Debut) [lsort -unique [set AQuiEstCeDebut($Debut)]]
lappend LesDebuts $Debut
}
set LesDebutsTries [lsort -unique -integer $LesDebuts]
set NouvelleListeDesPABs {}
foreach Debut $LesDebutsTries {
foreach Nom [set AQuiEstCeDebut($Debut)] {
set Ligne "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient]"
lappend NouveauBornesDesPABs $Ligne
lappend NouvelleListeDesPABs $Nom
}
}
if {$ReplaceFile} {
SauveLesLignes $NouveauBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs"
}
if {$ReplaceList} {
set ListeDesPABs $NouvelleListeDesPABs
set NouvelleListeDeBoites $NouvelleListeDesPABs
foreach Boite [ListeDeBoites] {
if {[info exists DejaVu($Boite)]} { continue }
set DejaVu($Boite) 1
lappend NouvelleListeDeBoites $Boite
}
set ListeDeBoites $NouvelleListeDeBoites
}
return $NouvelleListeDesPABs
}
proc ImprimeLesOrgaEtSesPlaces {} {
global RepertoireDuGenome
NousAllonsAuBoulot
foreach Fichier [glob "$RepertoireDuGenome/fiches/orgaetsesplaces.*"] {
set Texte "\n$Fichier\n\n[ContenuDuFichier $Fichier]"
set FichierTmp "tmp.[file tail $Fichier]"
Sauve $Texte dans $FichierTmp
eval exec renoir -l $FichierTmp
}
OnRevientDuBoulot
exit
}
proc RepriseDesVieuxInfos {Source PrefixeSource} {
global RepertoireDuGenome
global ListeDeBoites
set RepertoireSource $Source
if { ! [file exists $RepertoireSource]} {
set RepertoireRacine [file dirname $RepertoireDuGenome]
set RepertoireSource "$RepertoireRacine/$Source"
}
if { ! [file exists $RepertoireSource]} {
FaireLire "I cannot find $Source"
exit
}
set RepertoireDestin "$RepertoireDuGenome/infos"
if { ! [file exists $RepertoireDestin]} {
File mkdir $RepertoireDestin
}
set Garde 0
if {[llength [glob -nocomplain "$RepertoireDestin/*"]] > 0} {
set Garde [OuiOuNon "Do I keep the existing info files ?"]
}
if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
foreach Boite $ListeDeBoites {
set Nom [Box $Boite nom]
regsub [PreFixe] $Nom $PrefixeSource NomSource
set InfoSource "$RepertoireSource/infos/$NomSource"
set InfoDestin "$RepertoireDuGenome/infos/$Nom"
if {! [file exists $InfoSource]} { continue }
if {$Nom==$NomSource} {
if { $Garde && [file exists $InfoDestin]} { continue }
File copy $InfoSource $InfoDestin
continue
}
set Texte [ContenuDuFichier $InfoSource]
while {[regexp "$PrefixeSource\[0-9\]+" $Texte Match]} {
regsub $PrefixeSource $Match [PreFixe] Nouveau
regsub -all $Match $Texte $Nouveau Texte
}
Espionne [Sauve $Texte dans $InfoDestin]
}
}
proc LesClassesDuGlossaire {} {
global RepertoireDuGenome
foreach Complet [Glossaire "Coucou" "EntierComplet"] {
set Classe [OCduOS $Complet]
if {$Classe=="" || $Classe=="ClassUnknown"} {
scan $Complet "%s" Genre
if {[regexp -nocase "^Virus " $Complet]} {
set Classe "Virus."
} elseif {[info exists Classes($Genre)]} {
set Classe [set Classes($Genre)]
} else {
Espionne "$Complet:$Classe"
lappend LesUnknowns $Complet
continue
}
}
scan $Complet "%s" Genre
set Classes($Genre) $Classe
lappend CompletClasse "$Complet:$Classe"
}
Espionne [SauveLesLignes $LesUnknowns dans "$RepertoireDuGenome/fiches/completssansclasse"]
Espionne [SauveLesLignes $CompletClasse dans "$RepertoireDuGenome/fiches/organisme_classe"]
}
proc DeleteBallast {} {
global RepertoireDuGenome
foreach Fichier [glob "$RepertoireDuGenome/ballast/*"] {
File delete $Fichier
}
exit
}
proc OrdaliDuTexteMSF {MSF {FichierOrigine ""} {OptionsOrdali ""}} {
set FichierMSF [Sauve $MSF dans "[TmpFile "" "" "_"].msf"]
return [Ordali $FichierMSF $FichierOrigine "EnExec" $OptionsOrdali]
}
proc Ordali {{NomOuFichier ""} {FichierOrigine ""} {EnExec ""} {OptionsOrdali ""} {ForceXml ""}} {
global RepertoireDuGenome
global OrdaliDejaCharge
if {[string equal -nocase $FichierOrigine "ForceXml"]} {
set ForceXml "ForceXml"
set FichierOrigine $NomOuFichier
}
set ForceXml [string equal -nocase $ForceXml "ForceXml"]
if {$EnExec==""} {
global OrdaliEnExec
if {[info exists OrdaliEnExec]} {
set EnExec $OrdaliEnExec
} else {
set EnExec 1
}
}
if {[regexp "EnExec" $EnExec]} { set EnExec 1 }
if {[regexp "EnProc" $EnExec]} { set EnExec 0 }
set Nom [file tail $NomOuFichier]
if {0 && [regexp -nocase "xml" $NomOuFichier]} { set ForceXml 1 }
if {$ForceXml} {
if { ! [regexp "/" $NomOuFichier] && [EstUnPAB $Nom]} {
set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
if { ! [file exists $FichierXml]} {
append FichierXml ".xml"
}
} else {
set FichierXml $NomOuFichier
}
if {[file exists $FichierXml]} {
set Commande "tcsh -c \"setordalilm ; ordali -xml $FichierXml $OptionsOrdali\""
Espionne "Je vais faire exec $Commande &"
set Retour [eval exec $Commande &]
return $Retour
}
FaireLire "I can't find the XML file associated to $NomOuFichier. Sorry."
return ""
}
if {[EstUnPAB $NomOuFichier]} {
set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
if { ! [file exists $FichierXml]} {
append FichierXml ".xml"
}
if {[file exists $FichierXml]} {
set Commande "tcsh -c \"setordalilm; ordali -xml $FichierXml $OptionsOrdali\""
Espionne "Je vais faire exec $Commande &"
set Retour [eval exec $Commande &]
return $Retour
}
}
Espionne "on passe icic"
if {$OptionsOrdali==""} { set OptionsOrdali "-Group secator -Run" }
if {0 && ($FichierOrigine!="" || [regexp {msf[^/]*/} $FichierOrigine])} {
set FichierMSF $FichierOrigine
} else {
set FichierMSF $NomOuFichier
if { $Nom!="" && ![EstUnPAB $Nom] && [file exists $NomOuFichier]} {
set FichierMSF $NomOuFichier
}
if { $Nom!="" && [EstUnPAB $Nom] && [file exists "$RepertoireDuGenome/msf/$Nom"]} {
set FichierMSF "$RepertoireDuGenome/msf/$Nom"
}
}
if {$EnExec} {
if {[file exists $FichierMSF]} {
set FicPourOrdali $FichierMSF
#set RepPourOrdali [file dirname $FichierMSF]
#set FicPourOrdali [file tail $FichierMSF]
#NousAllonsAuBoulot $RepPourOrdali
#set Commande "tcsh -c \"setordalilm; ordali -MSF $FicPourOrdali $OptionsOrdali\""
#Espionne "execution de $Commande"
#set Retour [eval exec $Commande &]
#OnRevientDuBoulot
set Commande "tcsh -c \"setordalilm; ordali $FicPourOrdali $OptionsOrdali\""
Espionne "execution de $Commande"
set Retour [eval exec $Commande &]
return $Retour
} else {
set Commande "tcsh -c \"setordalilm; ordali\""
Espionne "Je vais executer $Commande"
return [eval exec $Commande &]
}
}
Espionne "Execution en proc"
set Fenetre [NomDe ordali]
if { ! [info exists OrdaliDejaCharge]} {
set OrdaliDejaCharge 1
LesDefauts
}
# if {$FichierMSF!=""} { InterpreteLaLigneDeCommande "-MSF $FichierMSF -NoCheckSeq $OptionSecator $OptionRun" }
if {$FichierMSF!=""} { InterpreteLaLigneDeCommande "-MSF $FichierMSF $OptionsOrdali" }
set FenetreOrdali [InitialiseFenetreOrdali slave $Fenetre]
return $FenetreOrdali
}
proc QuelleFonte F {
puts [font measure {Courier 8} X]
}
proc LireHori {Fichier {FichierSuivant ""}} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp "^PH" $Ligne]} { continue }
set LesMots [split $Ligne ","]
scan $LesMots "%s %s %d %d" NomLu PM Debut Fin
if {$PM=="+"} { set Orient "F" }
if {$PM=="-"} { set Orient "R" }
regsub -all -nocase {[a-z]} $NomLu "" Numero
scan $Numero "%d" N
set Nom [PreFixe][format "%4.4d" $N]
lappend LesBornes "$Nom $Debut $Fin $Orient"
}
if {$FichierSuivant!=""} {
set N [Maxi $Numero 3000]
foreach Ligne [LesLignesDuFichier $FichierSuivant] {
if { ! [regexp "^PH" $Ligne]} { continue }
set LesMots [split $Ligne ","]
scan $LesMots "%s %s %d %d" NomLu PM Debut Fin
if {$PM=="+"} { set Orient "F" }
if {$PM=="-"} { set Orient "R" }
set Nom [PreFixe][format "%4.4d" [incr N]]
lappend LesBornes "$Nom $Debut $Fin $Orient"
}
}
Espionne [SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs.nouveaux"]
}
proc TestRetourne {} {
set L {a b c d e f g}
puts [join $L " "]
puts [join [RetourneLaListe $L] " "]
}
proc Inventaire {{GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "Show" }
set Total [format "%5d" [llength [ListeDesPABs]]]
set Sortie [list "$Total [PreFixe] are available\n"]
foreach Toire [lsort [glob -type d "[RepertoireDuGenome]/*"]] {
set Queue [file tail $Toire]
set BeauQ [format "%16s" $Queue]
set Rep $Toire
set BeauToire [format "%-15s" $Toire]
if { ! [file exists $Rep] } {
lappend Sortie "$BeauToire doesn't exists."
continue
}
set LesPABs [lsort [glob -nocomplain "$Rep/[PreFixe]*"]]
set LesTous [lsort [glob -nocomplain "$Rep/*"]]
set N [llength $LesPABs]
set A [expr [llength $LesTous] - [llength $LesPABs]]
set BeauN [format "%5d" $N]
set BeauA [format "%5d" $A]
if {[info exists SesPABs]} { unset SesPABs }
set LesExt {}
foreach PAB $LesPABs {
if {[regexp "[PreFixe]\[0-9\]+(\[^0-9\]*)" $PAB Match Ext]} {
lappend LesExt $Ext
lappend SesPABs($Ext) $PAB
}
}
set LesExt [lsort -unique $LesExt]
if {[llength $LesExt]>1} {
foreach Ext $LesExt {
set LesPs $SesPABs($Ext)
set N [llength $LesPs]
set A [expr [llength $LesTous] - [llength $LesPs]]
set BeauN [format "%5d" $N]
set BeauA [format "%5d" $A]
lappend Sortie "$BeauN $BeauQ [PreFixe]1234[format %-12s $Ext] files and $BeauA other files in $BeauToire"
}
} else {
set Ext ""
lappend Sortie "$BeauN $BeauQ [PreFixe]1234[format %-12s $Ext] files and $BeauA other files in $BeauToire"
}
}
set LesFiches [lsort [glob -nocomplain "[RepertoireDuGenome]/fiches/*"]]
set LesPastouche [lsort [glob -nocomplain "[RepertoireDuGenome]/pastouche/*"]]
set Sortie [concat $Sortie [list "\n\n"] $LesFiches]
set Sortie [concat $Sortie [list "\n\n"] $LesPastouche]
if {[OnTraite OI]} { lappend Sortie "\n\n" [BlastLocalInventaire] }
set LeContenuPasTouche {}
foreach P [lsort [GlobRecursif "" "[RepertoireDuGenome]/pastouche"]] {
if {[info exists DejaVu($P)]} { FaireLire "$P deja vu en \n$DejaVu($P)" }
set DejaVu($P) $P
if {[file type $P]=="directory"} { continue }
lappend LeContenuPasTouche [ContenuDuFichier $P]
}
set ContenuPasTouche [join $LeContenuPasTouche "\n"]
lappend Sortie "\nContenu des pastouche"
lappend Sortie $ContenuPasTouche
set Sortie [join $Sortie "\n"]
#rR ............................................... on peut faire Affiche meme avec Wscope mais faut faire postpone des boutons
if {[PourWscope]} { return "<pre>$Sortie</pre>" }
if {$GetWhat=="GetText"} { return $Sortie }
set F [Affiche $Sortie "AvecShow" "Inventory at [Date Nice]"]
set B [BoutonneLaFenetre $F "NewInventory\nNew Check"]
$B configure -background "yellow"
bind $B <1> Inventaire
bind $B <Shift-1> CheckInventaire
return $F
}
proc Nommenclature {Nom {OrganismeComplet ""}} {
global RepertoireDuGenome
global Nommenclature
JeMeSignale
if {[info exists Nommenclature($Nom)]} {
Espionne "trouve [set Nommenclature($Nom)] [set Nommenclature($Nom,Complet)]"
if {$OrganismeComplet!=""} {
return "[set Nommenclature($Nom,Complet)]"
} else {
return "[set Nommenclature($Nom)]"
}
}
set FichierNommenclature "$RepertoireDuGenome/fiches/nommenclature"
if { ! [file exists $FichierNommenclature]} { return "" }
if { ! [info exists Nommenclature("EstCharge")]} {
foreach Ligne [LesLignesDuFichier $FichierNommenclature] {
scan $Ligne "%s %s %s %s" NomLu Alias Genre Espece
set GenEspe ""
append GenEspe "[string toupper [string range $Genre 0 0]]"
append GenEspe "[string tolower [string range $Genre 1 2]]"
append GenEspe "[string toupper [string range $Espece 0 0]]"
append GenEspe "[string tolower [string range $Espece 1 3]]"
set Nommenclature($NomLu) "${Alias}_$GenEspe"
set Nommenclature($NomLu,Complet) "$Genre $Espece"
}
set Nommenclature("EstCharge") "EtBienCharge"
return [Nommenclature $Nom $OrganismeComplet]
}
return ""
}
proc ChoisisTonBlast {FichierTFA FichierBlast {Programme ""} {Banque ""} {Ask ""}} {
global RepertoireDuGenome
global GscopeDir
if {$Ask=="DontAsk"} { set Ask 0 } else { set Ask 1 }
if {$Programme==""} {
set Programme [ChoixParmi {blastp blastx blastn tblastn tblastx Other}]
if {$Programme == "Other"} { set Programme [Entre] }
if {$Programme == ""} { return "" }
}
set AvecBanques "nucpro"
if {[regexp {^blastp$|^blastx$} $Programme]} {
regsub "nuc" $AvecBanques "" AvecBanques
}
if {[regexp {^tblastn$|^tblastx$|^blastn$} $Programme]} {
regsub "pro" $AvecBanques "" AvecBanques
}
if {$Banque==""} {
lappend LesRepertoiresDesBanques "$RepertoireDuGenome/banques"
lappend LesRepertoiresDesBanques "$RepertoireDuGenome/banquesblast"
lappend LesRepertoiresDesBanques "/catalog/blast"
set LesBanques {}
foreach RepBan $LesRepertoiresDesBanques {
if {[regexp "nuc" $AvecBanques]} {
set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.nsq"]]
set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.nal"]]
}
if {[regexp "pro" $AvecBanques]} {
set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.psq"]]
set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.pal"]]
}
}
set LesBonnesBanques {}
foreach Banque [lsort $LesBanques] {
regsub {\.nsq$|\.psq$|\.nal$|\.pal$} $Banque "" Banque
if {[info exists DejaVu($Banque)]} { continue }
set DejaVu($Banque) 1
lappend LesBonnesBanques $Banque
}
lappend LesBonnesBanques "Other"
set Banque [ChoixParmi $LesBonnesBanques]
if {$Banque == "Other"} {
set Banque [ButineArborescence "All" [RepertoireDuGenome]]
regsub {\.[np]..$} $Banque "" Banque
}
if {$Banque == ""} { return "" }
}
set CommandeBlast "$GscopeDir/gscope_batchcom.tcl eval exec blastall \
-p $Programme \
-i $FichierTFA \
-o $FichierBlast \
-d $Banque \
-v 500 \
-K 0 \
-b 500 \
-e 10.0 \
-F T "
if {$Ask} {
set CommandeBlast [Entre $CommandeBlast]
}
return $CommandeBlast
}
proc PartieNomsDesSequencesDuBlast {Fichier {AvecQuery ""}} {
DecortiqueBlast $Fichier \
"SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
set LesSeqs {}
if {$AvecQuery != ""} {
lappend LesSeqs $Query
}
foreach BanqueId $lBanqueId Access $lAccess DE $lDE {
lappend LesSeqs "$BanqueId $Access $DE"
}
set PartieNoms [join $LesSeqs "\n"]
return $PartieNoms
}
proc CreeUneBanqueBlast {{Selection ""} {RepBanquesBanque ""}} {
global RepertoireDuGenome
Wup "Selection can be 'AllProttfa' or 'AllNuctfa"
Wup "Creates a blast database with the sequences whose file names are in the text Selection"
Wup "If Banque doesn't contain a '/' I take RepertoireDuGenome/banques"
if {$Selection == "" } {
set LesPossibles [list "AllProttfa" "AllNuctfa" "DNA"]
global FichierSequenceADN
if {[info exists FichierSequenceADN] && [FileExists $FichierSequenceADN]} { lappend LesPossibles $FichierSequenceADN }
set Selection [ChoixParmi $LesPossibles]
if {$RepBanquesBanque == ""} { set RepBanquesBanque $Selection }
}
if {$Selection == "" } { return "" }
set SauveTFAs 1
set RepBanques "$RepertoireDuGenome/banques"
if {$RepBanquesBanque == "" } {
FaireLire "Please give me the name of the Blast Database."
set RepBanquesBanque [Entre "$RepBanques/$Selection"]
set Banque [file tail $RepBanquesBanque]
if {$Banque == ""} { return "" }
}
if { ! [regexp "/" $RepBanquesBanque]} { set RepBanquesBanque "$RepBanques/$RepBanquesBanque" }
set RepBanques [file dirname $RepBanquesBanque]
file mkdir $RepBanques
set Banque [file tail $RepBanquesBanque]
if {$Selection=="AllProttfa"} {
set RepTFA "prottfa"
}
if {$Selection=="AllNuctfa"} {
set RepTFA "nuctfa"
}
if {$Selection=="AllProttfa" || $Selection=="AllNuctfa"} {
set UseNomAliasDE [OuiOuNonMemo "Do I create new header with '>Nom Alias DE' ?\n if not I'll take the original fasta file"]
foreach Nom [ListeDesPABs] {
if {[Fantome $Nom]} { continue }
set FichierTFA "$RepertoireDuGenome/$RepTFA/$Nom"
if { ! [file exists $FichierTFA]} { continue }
set TFA [ContenuDuFichier $FichierTFA]
if {$UseNomAliasDE} {
set Seq [QueLaSequenceDuTexteTFA $TFA]
if {[string length $Seq]<1} { continue }
set Alias [Alias $Nom]
set DE [DefinitionRapide $Nom]
regsub "^>" $TFA ">$Nom $Alias $DE" TFA
}
lappend LesTFAs $TFA
}
set TFAs [join $LesTFAs "\n"]
} else {
set LaSelection [split $Selection "\n"]
if {$Selection==$RepBanquesBanque} {
set TFAs [ContenuDuFichier $Selection]
set SauveTFAs 0
} else {
set SauveTFAs 1
foreach Ligne $LaSelection {
scan $Ligne "%s" Fichier
if {[regexp "/" $Fichier] && [file exists $Fichier]} {
set TFAouTFAs [ContenuDuFichier $Fichier]
set Format [FormatDeLaSequence $TFAouTFAs]
if {$Format=="tfa" || $Format=="tfas"} {
lappend LesTFAs $TFAouTFAs
continue
}
}
set Access ""
scan $Ligne "%s %s" BanqueId Access
set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK]]
lappend LesTFAs $TFA
}
if {$LesTFAs == {} } { return "" }
set TFAs [join $LesTFAs "\n"]
}
}
set FormatProt "F"
foreach Ligne [split [string range $TFAs 0 2000] "\n"] {
if {[regexp "^>" $Ligne]} { continue }
if {[regexp -nocase {[DEFHIKLMPQSVWY]} $Ligne]} {
# Espionne $Ligne
set FormatProt "T"
break
}
}
if { ! [file exists $RepBanques]} { File mkdir $RepBanques }
if {$SauveTFAs} {
if {[file exists "$RepBanques/$Banque"]} {
if { ! [OuiOuNon "$RepBanques/$Banque\n exists. Overwrite ? "]} { return "" }
}
Sauve $TFAs dans "$RepBanques/$Banque"
}
NousAllonsAuBoulot $RepBanques
exec /biolo/ncbi/bin/formatdb -i $Banque -p $FormatProt
OnRevientDuBoulot
return "$RepBanques/$Banque"
}
proc CreeLesBanquesBlastDesTFAsPourTous {{RepTFAs ""} {RepBanques ""} {FormatProt ""}} {
if {$RepBanques==""} { set RepBanques "banquesdescopains" }
if {$RepTFAs==""} { set RepTFAs "tfasdescopains" }
file mkdir $RepBanques
set LesBanques {}
foreach Nom [ListeDesPABs] {
set FicTFAs [GscopeFile $Nom $RepTFAs]
if {[FileAbsent $FicTFAs]} { continue }
lappend LesBanques [CreeUneBanqueBlastDuTFAs $FicTFAs $RepBanques $FormatProt]
}
return $LesBanques
}
proc CreeUneBanqueBlastDuTFAs {FicTFAs {RepBanques ""} {FormatProt ""}} {
if {$FormatProt==""} { set FormatProt "T" }
if {$RepBanques==""} { set RepBanques "[RepertoireDuGenome]/banques" }
set Banque [file tail $FicTFAs]
regsub -nocase {\.tfa} $Banque "" Banque
file copy -force $FicTFAs "$RepBanques/$Banque"
NousAllonsAuBoulot $RepBanques
exec formatdb -i $Banque -p $FormatProt
OnRevientDuBoulot
return "$RepBanques/$Banque"
}
proc CreeUneBanqueBlastDuPAB {Nom {AvecQuery ""} {Rep ""}} {
if {$Rep==""} { set Rep "blastp" }
global RepertoireDuGenome
set PartieNom [PartieNomsDesSequencesDuBlast "$RepertoireDuGenome/$Rep/$Nom" $AvecQuery]
CreeUneBanqueBlast $PartieNom $Nom
return $PartieNom
}
proc CreeUneBanqueBlastDuBlast {Fichier {NomDeLaBanque ""} {AvecQuery ""}} {
global RepertoireDuGenome
if {$NomDeLaBanque==""} { set NomDeLaBanque [file tail $Fichier] }
set PartieNom [PartieNomsDesSequencesDuBlast $Fichier $AvecQuery]
CreeUneBanqueBlast $PartieNom $NomDeLaBanque
return $PartieNom
}
proc CreeLesCopains Nom {
global RepertoireDuGenome
set Destination "$RepertoireDuGenome/copains/$Nom"
if { ! [file isdirectory $Destination]} { File mkdir $Destination }
set LesCopains {}
if {[file exists "$RepertoireDuGenome/apns/$Nom"]} {
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/apns/$Nom"] {
scan $Ligne "%s %s" BanqueId Access
lappend LesCopains $Access
}
} else {
set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
if { ! [file exists $FichierBlast]} { return {} }
set PartieNoms [PartieNomsDesSequencesDuBlast $FichierBlast]
set LesHits [split $PartieNoms "\n"]
if {$LesHits == "" } { return {} }
foreach Ligne $LesHits {
set Access [AccessDUneLigneBlast $Ligne]
lappend LesCopains $Access
}
}
if {$LesCopains == {} } { return {} }
foreach Copain $LesCopains {
if {[file exists "$Destination/$Copain"]} { continue }
if {[file exists "$Destination/[string toupper $Copain]"]} { continue }
if {[file exists "$Destination/[string tolower $Copain]"]} { continue }
Espionne [Sauve [Fetche $Copain] dans "$Destination/$Copain"]
}
}
proc CreeLesCoBlastn Nom {
global RepertoireDuGenome
set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
if { ! [file exists $FichierBlast]} { return {} }
if { ! [file exists "$RepertoireDuGenome/banques/$Nom"]} {
set PartieNoms [CreeUneBanqueBlastDuPAB $Nom]
} else {
set PartieNoms [PartieNomsDesSequencesDuBlast $FichierBlast]
}
set LesQuerys [split $PartieNoms "\n"]
if {$LesQuerys == "" } { return {} }
set CommandeBlast "eval exec blastall \
-p blastn \
-i \$FichierTFA \
-o \$FichierBlast \
-d \$RepertoireDuGenome/banques/$Nom \
-v 500 \
-K 0 \
-b 500 \
-e 10.0 \
-F T "
set CommandeBlast [Entre $CommandeBlast]
if {$CommandeBlast==""} { return "" }
set Repertoire "$RepertoireDuGenome/coblastn/$Nom"
if { ! [file isdirectory "$Repertoire"]} {
File mkdir $Repertoire
}
set TestExistence 1
set GardeTout 0
foreach Ligne $LesQuerys {
set Query [AccessDUneLigneBlast $Ligne]
set FichierTFA [Sauve [SequenceFormatTFA [SequenceDesBanques $Query]] dans "tmp_coblastn.tfa"]
set FichierBlast "$Repertoire/$Query"
if { ! [file exists $FichierTFA]} {
Warne "$FichierTFA n'existe pas."
continue
}
if {$GardeTout && [file exists $FichierBlast] } {
continue
}
if { $TestExistence && [file exists $FichierBlast] } {
if {[OuiOuNon "Some blast files allready exists.\nDo I keep them ?"]} {
set TestExistence 0
} else {
if {[OuiOuNon "Do I keep all ?"]} { set GardeTout 1 }
if {$GardeTout || [OuiOuNon "$FichierBlast still exists.\nDo I keep it ?"]} { continue }
}
}
eval $CommandeBlast
Espionne $FichierBlast
}
}
proc CreeLesCoClustalw Nom {
global RepertoireDuGenome
global Commandes
set Repertoire "$RepertoireDuGenome/coclustalw/$Nom"
if { ! [file isdirectory "$Repertoire"]} {
File mkdir $Repertoire
}
foreach FichierCoBlastn [glob "$RepertoireDuGenome/coblastn/$Nom/*"] {
set Copain [file tail $FichierCoBlastn]
set Destination "$Repertoire/$Copain"
if {[file exists $Destination]} { continue }
set LesCopains {}
DecortiqueBlast $FichierCoBlastn 1.0e-80 25 Query lBanqueId lAccess lDE lProfil lPN
Espionne [join $lAccess "\n"]
if {[llength $lAccess] < 2} { continue }
set LesTFAsConcatenes {}
foreach Access $lAccess {
set FichierCopain "$RepertoireDuGenome/copains/$Nom/$Access"
if { ! [file exists $FichierCopain]} {
Warne "$Access n'est pas copain de $Copain"
continue
}
set TFA [SequenceFormatTFA [ContenuDuFichier $FichierCopain] $Access]
lappend LesTFAsConcatenes $TFA
}
if {[llength $LesTFAsConcatenes] < 2} { continue }
set Tmp "tmp.[pid][NomDe ""]"
set In "$Tmp.inp"
Sauve [join $LesTFAsConcatenes "\n"] dans $In
set Out $Tmp.out
set Log $Tmp.log
Warne "Clustalw sur $Nom $Access lance en interactif ... un peu de patience. Merci."
eval exec "[set Commandes(dbclustal)] $In $Out $Log"
Warne " ... j'ai fini."
# File delete -force $In
# File delete -force $Out
# File delete -force $Log
set MSF "$Out.msf"
Espionne "$MSF en $Destination"
if { ! [file exists $MSF]} { Warne "ai perdu $MSF" ; continue }
File copy $MSF $Destination
}
}
proc AfficheAssocie {Source CoRepertoire {Maniere ""}} {
global RepertoireDuGenome
regsub -nocase {\.[a-z_]*$} $Source "" Source
set Nom [file tail $Source]
set CheminSource [file dirname $Source]
set CheminCheminSource [file dirname $CheminSource]
set RepSource [file tail $CheminCheminSource]
regsub "$RepSource" $Source "$CoRepertoire" Nouveau
Wup "If Nouveau not found we try CoRepertoire/Nom"
foreach Nouveau [list $Nouveau "$RepertoireDuGenome/$CoRepertoire/$Nom"] {
if { ! [file exists $Nouveau]} { continue }
if {$Maniere=="" && [regexp "bla" $CoRepertoire]} {
set Maniere "AvecAligneursAvecSegAlignement"
}
return [AfficheFichier $Nouveau $Maniere]
}
FaireLire "Sorry, no file associated to\n$Source $CoRepertoire"
return ""
}
proc SansAmbiguite LesNouveaux {
foreach Nouveau $LesNouveaux {
set Numero 1
while {[info exists DejaVu($Nouveau)]} {
incr Numero
if {$Numero<10} {
regsub -nocase {[a-z0-9]$} $Nouveau $Numero Nouveau
} else {
regsub -nocase {[a-z0-9][a-z0-9]$} $Nouveau $Numero Nouveau
}
}
set DejaVu($Nouveau) 1
lappend LesNouveauxNouveaux $Nouveau
}
return $LesNouveauxNouveaux
}
proc MaquilleLeMSF {FichierMSF LesAnciens LesNouveaux {MaxAccess ""} {Force ""} {NouveauFichier ""}} {
global MaquilleNon
#rR attention si maquillon il faut mettre Force
#rR on remplace les anciens par les nouveaux
#rR on garde ceux qui ne sont pas dans la liste
#rR on ne tient pas compte des majuscules minuscule pour les anciens
#rR LesAnciens peut etre ReplaceNumberOnly. Dans ce cas LesNouveaux contient le caractere a mettre devant
set Force [string equal -nocase $Force "Force"]
if {$MaxAccess==""} { set MaxAccess 15 }
if { ! $Force && [info exists MaquilleNon] && $MaquilleNon} { return [LesLignesDuFichier $FichierMSF] }
set ReplaceNumberOnly 0
if {[string equal -nocase "ReplaceNumberOnly" $LesAnciens]} {
set ReplaceNumberOnly 1
set StartForNumber $LesNouveaux
}
foreach Ancien $LesAnciens Nouveau $LesNouveaux {
set ANCIEN [string toupper $Ancien]
set NouveauNom($ANCIEN) $Nouveau
}
set FormatName " Name: %-${MaxAccess}s %s"
set FormatAlig "%-[expr $MaxAccess+2]s %s"
set YaEuName 0
foreach Ligne [LesLignesDuFichier $FichierMSF] {
if {[regexp "Name: " $Ligne]} {
set YaEuName 1
scan $Ligne "%s %s" Name Ancien
set Nouveau $Ancien
if {$ReplaceNumberOnly} {
if {[regexp {^[0-9]+$} $Ancien]} { set Nouveau "$StartForNumber$Ancien" }
} else {
set ANCIEN [string toupper $Ancien]
if {[info exists NouveauNom($ANCIEN)]} { set Nouveau $NouveauNom($ANCIEN)}
}
set iLen [string first "Len:" $Ligne]
set NouvelleLigne [format $FormatName $Nouveau [string range $Ligne $iLen end]]
lappend LeNouveauMSF $NouvelleLigne
continue
}
if { ! $YaEuName || ! [regexp -nocase {[\.0-9a-z_]} $Ligne]} {
lappend LeNouveauMSF $Ligne
continue
}
scan $Ligne "%s" Ancien
regsub $Ancien $Ligne "" LigneAmputee
set LigneAmputee [string trimleft $LigneAmputee]
set Nouveau $Ancien
if {$ReplaceNumberOnly && [regexp -nocase {[a-z\.\-\~]} $Ligne]} {
if {[regexp {^[0-9]+$} $Ancien]} { set Nouveau "$StartForNumber$Ancien" }
} else {
set ANCIEN [string toupper $Ancien]
if {[info exists NouveauNom($ANCIEN)]} { set Nouveau $NouveauNom($ANCIEN)}
}
set NouvelleLigne [format $FormatAlig $Nouveau $LigneAmputee]
lappend LeNouveauMSF $NouvelleLigne
continue
}
if {$NouveauFichier!=""} { return [SauveLesLignes $LeNouveauMSF dans $NouveauFichier] }
return $LeNouveauMSF
}
proc StockeLesSequencesEtMaquilleLeMSF {FichierMSF Alias Nom} {
global RepertoireDuGenome
global MaquilleNon
JeMeSignale
set N [DecortiqueUnMSF $FichierMSF LesNoms Sequences]
set LeMSF [LesLignesDuFichier $FichierMSF]
File mkdir "$RepertoireDuGenome/copains/$Nom"
set MaquillageNecessaire 0
foreach NomDeSequence $LesNoms {
if {[regexp "tfiih" "$RepertoireDuGenome"] && \
[set NouveauNom [Nommenclature $NomDeSequence]] != "" } {
Espionne $NouveauNom
set OS [Nommenclature $NomDeSequence "OrganismeComplet"]
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $NouveauNom; cree par rR d'apres Nommenclature et MSF $FichierMSF"
lappend LesLignesEMBL "AC $NouveauNom"
lappend LesLignesEMBL "DE $NouveauNom"
lappend LesLignesEMBL "OS $OS"
lappend LesLignesEMBL "OC [OCduOS $OS]"
lappend LesLignesEMBL [QueSequenceFormatEMBL [set Sequences($NomDeSequence)] "AvecSQ"]
} elseif {[regexp -nocase {^[a-z]+_[a-z]+$} $NomDeSequence]} {
set G [string index $NomDeSequence 0]
set Esp [string range [StringSuivant "_" dans $NomDeSequence] 0 2]
set GEsp [string tolower "${G}$Esp"]
set OS [Glossaire $GEsp "Complet"]
set LesLignesEMBL {}
set NouveauNom $NomDeSequence
Espionne "$NouveauNom $OS"
lappend LesLignesEMBL "ID $NouveauNom; cree par rR car Genr_Espe et MSF $FichierMSF"
lappend LesLignesEMBL "AC $NouveauNom"
lappend LesLignesEMBL "DE $NouveauNom"
lappend LesLignesEMBL "OS $OS"
lappend LesLignesEMBL "OC [OCduOS $OS]"
lappend LesLignesEMBL [QueSequenceFormatEMBL [set Sequences($NomDeSequence)] "AvecSQ"]
} else {
set LesLignesEMBL [LaSequenceDesBanques $NomDeSequence $NomDeSequence AccessOK "OnVeutEMBL"]
if {$LesLignesEMBL == {}} {
if { ! [info exists Ask]} {
set Ask [OuiOuNonMemo "Do You want to help me for each definition, orga, etc. ?"]
}
if {$Ask && ! [OuiOuNon "$NomDeSequence cannot be found in databases. I'll create the EMBL file.\n\
Do You want to give a name ?"]} {
set NouveauNom [Entre "$NomDeSequence"]
} else {
set NouveauNom $NomDeSequence
}
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $NouveauNom; cree par rR d'apres MSF $FichierMSF."
lappend LesLignesEMBL "AC $NouveauNom"
if {$Ask} {
lappend LesLignesEMBL "DE [Entre definition]"
set Organisme [Entre "Genus species"]
lappend LesLignesEMBL "OS $Organisme"
lappend LesLignesEMBL "OC [OCduOS $Organisme]"
}
lappend LesLignesEMBL [QueSequenceFormatEMBL [set Sequences($NomDeSequence)] "AvecSQ"]
} else {
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
if { ! [info exists MaquilleNon] || ! $MaquilleNon} {
set Organisme [OrganismeCanonique $OS]
if {$Organisme==""} {
if {[set Organisme [Nommenclature $NomDeSequence "OrganismeComplet"]] == "" } {
set Organisme "Unknown unknown"
}
}
scan $Organisme "%s %s" Genre Espece
set GenEspe ""
append GenEspe "[string toupper [string range $Genre 0 0]]"
append GenEspe "[string tolower [string range $Genre 1 2]]"
append GenEspe "[string toupper [string range $Espece 0 0]]"
append GenEspe "[string tolower [string range $Espece 1 3]]"
set NouveauNom "${Alias}_$GenEspe"
} else {
set NouveauNom $NomDeSequence
}
}
}
lappend LesSequencesEMBL $LesLignesEMBL
if {$NomDeSequence!=$NouveauNom} { set MaquillageNecessaire 1 }
lappend LesAnciens $NomDeSequence
lappend LesNouveaux $NouveauNom
continue
}
set LesNouveaux [SansAmbiguite $LesNouveaux]
foreach Nouveau $LesNouveaux LesLignesEMBL $LesSequencesEMBL {
SauveLesLignes $LesLignesEMBL dans "$RepertoireDuGenome/copains/$Nom/$Nouveau"
}
if {$MaquillageNecessaire} {
set LeNouveauMSF [MaquilleLeMSF $FichierMSF $LesAnciens $LesNouveaux]
} else {
set LeNouveauMSF [LesLignesDuFichier $FichierMSF]
}
return $LeNouveauMSF
}
proc ChargeNarcisseDuAlias {{Fichier ""}} {
global RepertoireDuGenome
global NarcisseDuAlias
if {$Fichier==""} {
set Fichier [ButineArborescence "All" "$RepertoireDuGenome"]
}
if {$Fichier==""} { return 0 }
set n 0
foreach Ligne [LesLignesDuFichier $Fichier] {
incr n
if { ! [regexp -nocase {[a-z]+} $Ligne]} { continue }
if {[regexp -nocase {^[ \t]*\#} $Ligne]} { continue }
regsub -all "\t" $Ligne " " Ligne
set Access ""
set Alias "ALIAS_$n"
set DE ""
if {[OuiOuNonMemo "Does this file contain BanqueId AND Access (Alias (Definition)) ?"]} {
scan $Ligne "%s %s %s" BanqueId Access Alias
regsub "\:" $BanqueId "\\:" BanqueIdSansPP
regsub " *$BanqueIdSansPP +$Access +$Alias +" $Ligne "" DE
} else {
scan $Ligne "%s %s" Access Alias
regsub " *$Access +$Alias +" $Ligne "" DE
}
if {$Access==""} { set Access $BanqueId }
set NarcisseDuAlias($Alias) $Access
}
return $n
}
proc CreeBornesDesPABsPourUneCollection {FOF {RefaireCeNomUniquement ""}} {
global RepertoireDuGenome
global ListeDeBoites
global ListeDesPABs
global InformeSansDemander
JeMeSignale
Wup "On peut refaire un nom s'il existe deja. Supprimer les copains et autres."
if { ! [info exists NarcisseDuAlias]} {
if {[OuiOuNon "I need help to create Narcisse.\nOnce again, could You browse for a file with 'Access Alias' ?" 0]} {
ChargeNarcisseDuAlias
}
}
set OnEnRajoute 0
set Conserve 0
if { [file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} {
if {[OuiOuNon "$RepertoireDuGenome/fiches/bornesdespabs still exists.\n Do I stop ?"]} {
exit
}
if { ! [OuiOuNon "Do You want to keep the existing files ?"]} {
File rename -force "$RepertoireDuGenome/fiches/bornesdespabs"\
"$RepertoireDuGenome/fiches/bornesdespabs.old"
} else {
if { ! [OuiOuNon "The new elements have to be at the end of the $FOF ...\nOK ?"]} {
exit
}
set OnEnRajoute 1
set Conserve 1
if { ! [info exists ListeDesPABs]} { ListeDesPABs }
}
}
if { ! [file exists "$RepertoireDuGenome/msf"]} {
File mkdir "$RepertoireDuGenome/msf"
}
if { ! [file exists "$RepertoireDuGenome/ballast"]} {
File mkdir "$RepertoireDuGenome/ballast"
}
if { ! [file exists "$RepertoireDuGenome/blastp"]} {
File mkdir "$RepertoireDuGenome/blastp"
}
if { ! [file exists "$RepertoireDuGenome/copains"]} {
File mkdir "$RepertoireDuGenome/copains"
}
if { ! [file exists "$RepertoireDuGenome/ver"]} {
File mkdir "$RepertoireDuGenome/ver"
}
set ORF [PreFixe]
set Numero 0
if { ! [OuiOuNon "Do I start $ORF numbering with [expr $Numero+1]"]} {
set Numero [Entre 1]
incr Numero -1
}
set Debut 0
set Fin [expr $Debut + 900 - 1]
set Saut 1000
set Orient "F"
set LesPABsExistants {}
if {[info exists ListeDesPABs]} {
foreach PAB $ListeDesPABs {
if {[EstUnPABMute $PAB]} {
lappend LesMutants($Papa) $PAB
continue
}
lappend LesPABsExistants $PAB
set Papa $PAB
}
}
set LesBornes {}
set LesLignes [LesLignesDuFichier $FOF]
foreach Ligne [LesLignesDuFichier $FOF] {
if { ! [regexp -nocase {[A-Z0-9_]} $Ligne]} { continue }
set Alias ""
catch {unset Nom}
catch {unset Ver}
catch {unset OrigineBlastP}
catch {unset OrigineBallast}
catch {unset OrigineMSF}
set NbLus [scan $Ligne "%s %s %s %s %s %s" Alias OrigineVer OrigineBlastP OrigineBallast OrigineMSF SecondMSF]
if {$NbLus < 2} {
set OrigineVer $Alias
set Alias ""
if {[OuiOuNonMemo "I got some lines with only one word. Do I use the access I'll find as alias. For all ??"]} {
set TexteVer [ContenuDuFichier $OrigineVer]
while 1 {
if { ! [regexp {^>([^ ]+)} $TexteVer Match AliasLu]} { set Alias $AliasLu; break }
if { ! [regexp {\nAC ([^;]+)} $TexteVer Match AliasLu]} { set Alias $AliasLu; break }
}
}
if {$Alias==""} {
if {[OuiOuNon "$Ligne\n missing values. Do I stop ?"]} { exit }
continue
}
}
set Nom [format "%s%[FormatDesNumerosPourCollection]" $ORF [incr Numero]]
# if {[regexp "^bidonPour" $Alias]} { continue }
if {[EstUnPAB $Alias] && $Alias==$Nom } { continue }
if {[EstUnPAB $Alias] && $Alias!=$Nom } {
FaireLire "$Alias should be $Nom"
continue
}
if { [FileExists "[RepertoireDuGenome]/fiches/bornesdespabs"] && [Alias $Nom]!=$Alias} {
if {(! [info exists InformeSansDemander] || ! $InformeSansDemander) \
&& [OuiOuNon "Do I stop asking for Informe ? "]} {
set InformeSansDemander 1
}
Informe $Nom "=Alias: $Alias"
}
if {$RefaireCeNomUniquement=="$Nom"} {
set Refaire 1
} else {
set Refaire 0
if {$LesPABsExistants != {} } {
set PAB [lindex $LesPABsExistants 0]
set LesPABsExistants [lrange $LesPABsExistants 1 end]
set GN [NomDeGene $Nom]
while {$PAB!=$Nom || ($GN!=$PAB && $GN!=$Alias)} {
if {[OuiOuNon "$Ligne\n$PAB vs $Nom\n$GN vs $Alias\n don't correspond ... Do I stop ?"]} { exit }
if {[OuiOuNon "Do I ignore that Alias $Alias is not GeneName $GN"]} { break }
set MemoInformeSansDemander $InformeSansDemander
set InformeSansDemander 0
Informe $Nom
set InformeSansDemander $MemoInformeSansDemander
}
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
lappend LesBornes "$PAB $Debut $Fin $Orient"
if {[info exists LesMutants($PAB)]} {
foreach PABMut [set LesMutants($PAB)] {
set Debut [Box $PABMut debut]
set Fin [Box $PABMut fin]
set Orient [Box $PABMut orient]
lappend LesBornes "$PABMut $Debut $Fin $Orient"
}
}
continue
}
}
if { [info exists SecondMSF] && [file exists $SecondMSF] } {
set MSF "$RepertoireDuGenome/msf2/$Nom"
if { ! [file exists "$MSF"] || ! $Conserve || $Refaire} {
File copy $SecondMSF $MSF
}
}
if { [info exists OrigineMSF] && [file exists $OrigineMSF] } {
set MSF "$RepertoireDuGenome/msf/$Nom"
if { ! [file exists "$MSF"] || ! $Conserve || $Refaire} {
set LeBeauMSF [StockeLesSequencesEtMaquilleLeMSF $OrigineMSF $Alias $Nom]
SauveLesLignes $LeBeauMSF dans $MSF
}
}
if { [info exists OrigineBallast] && [file exists $OrigineBallast] } {
set Ballast "$RepertoireDuGenome/ballast/$Nom"
if { ! [file exists "$Ballast"] || ! $Conserve || $Refaire} {
File copy $OrigineBallast $Ballast
}
}
if { [info exists OrigineBlastP] && [file exists $OrigineBlastP] } {
set BlastP "$RepertoireDuGenome/blastp/$Nom"
if { ! [file exists "$BlastP"] || ! $Conserve || $Refaire} {
File copy $OrigineBlastP $BlastP
}
}
if { [info exists OrigineVer] && [file exists $OrigineVer] } {
set Ver "$RepertoireDuGenome/ver/$Nom"
if { ! [file exists "$Ver"] || ! $Conserve || $Refaire} {
File copy -force $OrigineVer $Ver
}
}
incr Debut $Saut
incr Fin $Saut
Box $Nom nom $Nom
Box $Nom debut $Debut
Box $Nom fin $Fin
Box $Nom orient $Orient
Box $Nom frame [NomDeLaFrame [expr $Debut%3] $Orient]
Box $Nom long [expr $Fin-$Debut+1]
lappend ListeDesPABs $Nom
lappend ListeDeBoites $Nom
lappend LesBornes "$Nom $Debut $Fin F"
if {[regexp "thetase" "$RepertoireDuGenome"]} {
set AA3 [AADuNomDuFichier [file tail $OrigineMSF] "SansAlias"]
Informe $Nom "=ValiGN: ${AA3}rs"
}
if {[regexp "/NR$" "$RepertoireDuGenome"]} {
Informe $Nom "=ValiGN: $Alias"
}
if {[regexp "nag" "$RepertoireDuGenome"]} {
Informe $Nom "=ValiGN: $Alias"
}
if {[regexp "tfiih" "$RepertoireDuGenome"]} {
Informe $Nom "=ValiGN: $Alias"
}
# if {$RefaireCeNomUniquement==$Nom} { exit }
Espionne fin
}
SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs"
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.