Index by: file name |
procedure name |
procedure call |
annotation
gscope_bigbang.tcl
(annotations | original source)
#rR gscope_bigbang.tcl
proc NotreOS {{Valeur ""}} {
global NotreOS
if {$Valeur!=""} { set NotreOS $Valeur }
if {[info exists NotreOS]} { return $NotreOS }
return ""
}
proc NotreOC {{Valeur ""}} {
global NotreOC
if {$Valeur!=""} { set NotreOC $Valeur }
if {[info exists NotreOC]} { return $NotreOC }
set NOS [NotreOS]
if {$NOS==""} { return "" }
if {$NOS=="Inconnu inconnu"} { return "" }
return [OCduOS $NOS]
}
proc NotreOX {{Valeur ""}} {
global NotreOX
if {$Valeur!=""} { set NotreOX $Valeur }
if {[info exists NotreOX]} { return $NotreOX }
set NOS [NotreOS]
if {$NOS==""} { return "" }
if {$NOS=="Inconnu inconnu"} { return "" }
regsub -all " " $NOS "_" NOS
set NotreOX [Tax $NOS TaxId]
return $NotreOX
}
proc NotreTaxId {} {
return [NotreOS]
}
proc WhichBanqueTBlastN {{BanqueTBlastN ""}} {
if {$BanqueTBlastN!=""} { return $BanqueTBlastN }
set LesBanquesTBlastNPossibles [glob -nocomplain "[RepertoireDuGenome]/tblastn*"]
if {[llength $LesBanquesTBlastNPossibles]==0} {
set BanqueTBlastN ""
} else {
set RepTBlastN [lindex $LesBanquesTBlastNPossibles 0]
if {[llength $LesBanquesTBlastNPossibles]>1} {
FaireLire "Please tell me which tblastn you want to use"
set RepTBlastN [ChoixParmi $LesBanquesTBlastNPossibles]
}
set BanqueTBlastN [StringApres "/tblastn" dans $RepTBlastN]
}
return $BanqueTBlastN
}
proc OuSuisJe {} {
set Ici [info script]
Espionne $Ici
return [Realpath $Ici]
}
proc RepriseDeOldBsuX {} {
global RepertoireDuGenome
foreach Bornes [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdespabs"] \
OldBor [LesLignesDuFichier "/genomics/link/OldBsuX/fiches/bornesdespabs"] {
if {$Bornes==$OldBor} {
scan $Bornes "%s" Nom
foreach Rep {apns blastp descriptifs msf aliinout tfasdescopains} {
set S "/genomics/link/OldBsuX/$Rep"
set D "$RepertoireDuGenome/$Rep"
Espionne " Copie de $Rep/$Nom"
if { ! [file exists "$S/$Nom"] || [file exists "$D/$Nom"]} { continue }
File copy "$S/$Nom" "$D/$Nom"
}
}
}
exit
}
proc NomDeFamille Nom {
global NomDeFamille
set NomDeFamilleDansAlias 1
if {[info exists NomDeFamille($Nom)]} {return [set NomDeFamille($Nom)]}
if {[info exists NomDeFamille("EstCharge")]} {return "UnknownFamily"}
set NomDeFamille(LaListeMerci) {}
foreach PAB [ListeDesPABs] {
set Fam "UnknownFamily"
if {$NomDeFamilleDansAlias} {
set Alias [Alias $PAB]
regsub {_.*$} $Alias "" Fam
}
set NomDeFamille($PAB) $Fam
if { ! [info exists DejaVu($Fam)]} {
lappend NomDeFamille(LaListeMerci) $Fam
set DejaVu($Fam) $PAB
}
}
set NomDeFamille("EstCharge") 1
return [NomDeFamille $Nom]
}
proc NiveauParFamille {} {
global RepertoireDuGenome
set Niveau 1
set OldFamille ""
set Debut 1
set Longueur 899
set Orient "F"
foreach Nom [ListeDesPABs] {
set Famille [NomDeFamille $Nom]
if {$Famille!=$OldFamille} {
set Niveau [expr -$Niveau]
incr Debut $Niveau
}
incr Debut 999
set Fin [expr $Debut+$Longueur]
lappend LesBornes "$Nom $Debut $Fin $Orient"
Espionne "$Nom $Alias $Famille $Debut $Niveau"
set OldFamille $Famille
}
Espionne [SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs.niveauparfamille"]
exit
}
proc ChangeGenome {{Genome ""}} {
global RepertoireDuGenome
global RepertoireRacineDuGenome
global LesBoutonsDeVitrine
global LesBoutonsDeVitrineCaches
global LesBoutonsNonOpen
global VariableADetruire
if {$Genome!=""} {
set GenomeOrigine $Genome
if { ! [file exists $Genome]} {
set Genome "$RepertoireDuGenome/../[file tail $Genome]"
}
if { ! [file exists $Genome]} {
if { [OuiOuNon "$GenomeOrigine\n and \n$Genome\n don't exist.\n Do I cancel ?"]} {
return "Cancel"
}
}
}
while { ! [file exists $Genome]} {
if { ! [OuiOuNon "Do You want to display another genome or collection." 0]} { return "Cancel" }
set Genome [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
if {$Genome==""} {
if {[OuiOuNon "Do I cancel ?"]} { return "Cancel" }
continue
}
break
}
set genome $Genome
set monNiveau [info level]
if {[info exists LesBoutonsDeVitrineCaches]} {
foreach b $LesBoutonsDeVitrineCaches {
catch {destroy $b}
}
}
if {[info exists LesBoutonsDeVitrine]} {
foreach b $LesBoutonsDeVitrine {
catch {destroy $b}
}
}
if {[info exists LesBoutonsNonOpen]} {
foreach b $LesBoutonsNonOpen {
catch {destroy $b}
}
}
set lesVariables [uplevel {info vars}]
foreach variable $lesVariables {
Espionne "variable testee $variable"
if {[EstUneVariableGlobaleGenerale $variable]} { continue }
Espionne "Variable detruite .................. $variable"
set VariableADetruire $variable
uplevel $monNiveau {unset $VariableADetruire}
}
set RepertoireDuGenome $Genome
set env(REPERTOIREDUGENOME) $RepertoireDuGenome
uplevel $monNiveau ChargeConfig
uplevel $monNiveau Gscope
}
proc ReadLink {Lien {Rep ""}} {
if {[file type $Lien]=="link" && ! [regexp "^/" [file readlink $Lien]]} {
set Lien "$Rep/[file readlink $Lien]"
}
if {[file type $Lien]=="link"} {
set Lien [file readlink $Lien]
}
return $Lien
}
proc LocaliseTBlastNDataBase {{NomDeLaBanque ""}} {
return [LocaliseBlastNDataBase $NomDeLaBanque "T"]
}
proc LocaliseBlastNDataBase {{NomDeLaBanque ""} {T ""}} {
global RepertoireDuGenome
Wup "Creates the correct link or database in ./banques"
Wup "ATTENTION : If NomDeLaBanque is not empty returns it immediately ... a ameliorer"
if {$NomDeLaBanque!=""} { return $NomDeLaBanque }
set RepDesBanques "$RepertoireDuGenome/banques"
if { ! [file exists $RepDesBanques]} { File mkdir $RepDesBanques }
set BlastNDataBaseDefaut "/catalog/blast/human.nal"
if {$T=="T"} {
set BlastNDataBase "$RepDesBanques/tblastndatabase"
} else {
set BlastNDataBase "$RepDesBanques/blastndatabase"
}
if {[file exists $BlastNDataBase] && [file type $BlastNDataBase]=="link"} {
set BlastNDataBase [ReadLink $BlastNDataBase $RepDesBanques]
}
while { ! [file exists "$BlastNDataBase"]} {
if {[OuiOuNon "You didn't define the (T)BlastN database.\n \
Do You want to use $BlastNDataBaseDefaut ?"]} {
eval exec "ln -sf $BlastNDataBaseDefaut $BlastNDataBase"
set BlastNDataBase [ReadLink $BlastNDataBase $RepDesBanques]
continue
}
if {[OuiOuNon "You didn't define the BlastN database.\n \
You can create your own database in $RepDesBanques\n \
Do You want to do it now ?"]} {
FaireLire "Do it before answering"
return [LocaliseBlastNDataBase]
}
if {[OuiOuNon "Do I exit ?"]} { exit }
if {[OuiOuNon "Do I cancel BlastN ?"]} { return "" }
}
regsub {\.(nal|nhr)$} $BlastNDataBase "" BlastNDataBase
return $BlastNDataBase
}
proc LocalisePsiBlastPDataBase {{Banque ""}} {
return [LocaliseBlastPDataBase $Banque]
}
proc DedicatedBlastDatabase {{Rep ""}} {
global DedicatedBlastDatabase
if {$Rep=="Reset"} { set DedicatedBlastDatabase "" ; return "" }
if {$Rep==""} {
if {[info exists DedicatedBlastDatabase]} { return $DedicatedBlastDatabase }
}
set DedicatedBlastDatabase $Rep
return $DedicatedBlastDatabase
}
proc LocaliseBlastPDataBase {{Banque ""}} {
global RepertoireDuGenome
Wup "Creates the correct link or database in ./banques"
if {[regexp {_dedicated_(.+)$} $Banque Match Rep]} {
regsub {_dedicated_(.+)$} $Banque "" B
set Loc [LocaliseBlastPDataBase $B]
DedicatedBlastDatabase $Rep
Espionne $Loc
return $Loc
}
if {[regexp "/" $Banque]} { return $Banque }
if {$Banque!=""} {
set Possible "[RepertoireDuGenome]/banques/$Banque"
if {[file exists $Possible] \
|| [file exists $Possible.phr] \
|| [file exists $Possible.pal] } {
return $Possible
}
set Possible "/catalog/blast/$Banque"
if {[file exists $Possible] \
|| [file exists $Possible.phr] \
|| [file exists $Possible.pal] } {
return $Possible
}
FaireLire "Attention la banque ne peut etre que dans [RepertoireDuGenome]/banques/"
}
set RepDesBanques "$RepertoireDuGenome/banques"
if { ! [file exists $RepDesBanques]} { File mkdir $RepDesBanques }
set BlastPDataBaseDefaut "/catalog/blast/protall.pal"
set BlastPDataBase "$RepDesBanques/blastpdatabase"
#rR 20200526 j'ai fait les choses correctemetn pour pouvoir lire le lien
if {[file type $BlastPDataBase]=="link"} {
set BlastPDataBase [ReadLink $BlastPDataBase $RepDesBanques]
}
#rR 20200526 et tester .phr
while { ! [file exists $BlastPDataBase] && ! [file exists "$BlastPDataBase.phr"]} {
if {[OuiOuNon "You didn't define the BlastP database.\n \
Do You want to use $BlastPDataBaseDefaut ?"]} {
eval exec "ln -sf $BlastPDataBaseDefaut $BlastPDataBase"
set BlastPDataBase [ReadLink $BlastPDataBase $RepDesBanques]
continue
}
if {[OuiOuNon "You didn't define the BlastP database.\n \
You can create your own database in $RepDesBanques\n \
Do You want to do it now ?"]} {
FaireLire "Do it before answering"
return [LocaliseBlastPDataBase]
}
if {[OuiOuNon "Do I exit ?"]} { exit }
if {[OuiOuNon "Do I cancel BlastP ?"]} { return "" }
}
regsub {\.(pal|phr)$} $BlastPDataBase "" BlastPDataBase
return $BlastPDataBase
}
proc FinPasTouche Nom {
PasTouche $Nom "fin"
}
proc TestPasTouche {} {
return [PasTouche Bidon12345]
}
proc PasTouche {Nom {Action ""}} {
global RepertoireDuGenome
Wup "Returns 1 if Nom in use, else uses it and returns 0"
Wup " if Action is fin then release Nom and returns 0"
Wup " if Action is test then tests only but doesn't use"
Wup " if Nom is ListAll, it returns the text of all files"
set RepPasTouche "[RepertoireDuGenome]/pastouche"
set Action [string tolower $Action]
#rR Pour voir s'il n'y en a pas qui trainent (à ne pas confondre avec test)
if {$Nom=="Check"} {
while {[set Etat [PasTouche "ListAll"]]!=""} {
if {[OuiOuNon "Attention, following processes are running\n$Etat\nDo I exit ?" 0]} { exit }
if {[OuiOuNon "Do I ignore it ?"]} { return 1 }
}
return 0
}
if {[regexp -nocase "ListAll" $Nom]} {
set LesEnCours [GlobRecursif "*" $RepPasTouche]
if {$LesEnCours=={}} { return {} }
set Etat {}
foreach FPT $LesEnCours {
if {[FileAbsent $FPT]} { continue }
regsub {^.+/pastouche/} $FPT "" FileName
set FileName [string trimleft $FileName "./"]
if {[file type $FPT]=="directory"} {
if { [regexp -nocase "Dir" $Nom]} { lappend LesFichiers $FileName }
continue
}
if {[FileAbsent $FPT]} { continue }
if {[catch {lappend Etat [ContenuDuFichier $FPT]}]} { continue }
lappend LesFichiers $FileName
}
if {[regexp -nocase "Files" $Nom ]} { return $LesFichiers }
return [join $Etat "\n"]
}
if {$Action=="" && [file exists "$RepPasTouche/stopall"]} {
Warne "I exit because I found $RepPasTouche/stopall"
exit
}
if {$Action=="" && ([file exists "$RepPasTouche/stop[pid]"] || [file exists "$RepPasTouche/stop$Nom"])} {
Warne "I exit because I found $RepPasTouche/stop[pid] or $RepPasTouche/stop$Nom"
exit
}
set FichierPasTouche "$RepPasTouche/$Nom"
if {$Action=="fin"} {
if {[file exists $FichierPasTouche]} {
catch { file delete -force $FichierPasTouche }
}
return 0
}
if {[file exists $FichierPasTouche]} { return 1 }
if {$Action!="test"} {
if { ! [file exists [set Rep [file dirname $FichierPasTouche]]]} { file mkdir $Rep }
Sauve "Ne me touche pas ..." dans $FichierPasTouche
set Message "$Nom en cours sur [Hostname] , pid [pid] depuis [Date Nice] = [info level -1]"
regsub {[\n]} $Message " " Message
set Message [string range $Message 0 131]
Sauve $Message dans $FichierPasTouche
}
return 0
}
proc StopAllGscope {{Action ""}} {
set Action [string totitle $Action]
set RepPasTouche "[RepertoireDuGenome]/pastouche"
set FichierStopAll "$RepPasTouche/stopall"
if {$Action=="Test" } { return [file exists $FichierStopAll] }
if {$Action=="Delete"} { file delete -force $FichierStopAll ; return "" }
if {$Action!="Force" } {
if { ! [OuiOuNon "Ok to stop all running gscope on \n[RepertoireDuGenome]\n through pastouche/stopall" 0]} {
return "No"
}
}
Sauve "StopAll demande sur [info hostname] , pid [pid] depuis [Date Nice] = [info level -1]" dans $FichierStopAll
file attribute $FichierStopAll -permissions 0777
return $FichierStopAll
}
proc PrefixeDuProjet Projet {
return [PrefixeDuGenome $Projet]
}
proc PrefixeDuGenome Genome {
set GenOri $Genome
if { ! [regexp "/" $Genome]} {
set Genome "[GscopeDatabaseDir $Genome]"
}
set FichierMiniConfig "$Genome/beton/miniconfig"
Espionne $FichierMiniConfig
if { ! [file exists $FichierMiniConfig]} {
FaireLire "I can't find $FichierMiniConfig\n to determine the PreFixe of $GenOri"
return "AAAA"
}
foreach Ligne [LesLignesDuFichier $FichierMiniConfig] {
if {[regexp "PrefixeDesORFs" $Ligne]} {
regsub "PrefixeDesORFs " $Ligne "" Prefixe
return $Prefixe
}
}
FaireLire "I can't find 'PreFixe' in $FichierMiniConfig\n to determine the PreFixe of $GenOri"
return "AAAA"
}
proc FormatDesNumerosPourCollectionDuProjet {{Projet ""}} {
return [FormatDesNumerosPourCollectionDuGenome $Projet]
}
proc FormatDesNumerosPourCollectionDuGenome {{Genome ""}} {
if {$Genome==""} { set Genome [RepertoireDuGenome] }
if { ! [regexp "/" $Genome]} {
set Genome "[GscopeDatabaseDir $Genome]"
}
set Fichier "$Genome/fiches/format_orf_numbering"
if {[FileExists $Fichier]} {
scan [ContenuDuFichier $Fichier] "%s" F
return $F
}
set FichierBornes "$Genome/fiches/bornesdespabs"
scan [ContenuDuFichier $FichierBornes] "%s" PremierNom
if { ! [regexp {[0-9]+$} $PremierNom Match]} { return "" }
set N [string length $Match]
return "$N.${N}d"
}
proc OrganismeDuGenome Genome {
global RepertoireDuGenome
set GenOri $Genome
if { ! [file exists $Genome]} {
set Genome "$RepertoireDuGenome/../$Genome"
}
set FichierMiniConfig "$Genome/beton/miniconfig"
if { ! [file exists $FichierMiniConfig]} {
FaireLire "I can't find $FichierMiniConfig\n to determine the organism of $GenOri"
return "Unknow unknow"
}
foreach Ligne [LesLignesDuFichier $FichierMiniConfig] {
if {[regexp "NotreOS" $Ligne]} {
regsub "NotreOS " $Ligne "" Organisme
regsub {\.} $Organisme "" Organisme
return $Organisme
}
}
FaireLire "I can't find 'NotreOS' in $FichierMiniConfig\n to determine the organism of $GenOri"
return "Unknow unknow"
}
proc LesNomsGscopeDeLOrganisme Organisme {
global RepertoireDuGenome
global LesNomsGscopeDeLOrganisme
set Organisme [Glossaire $Organisme Complet]
if {[info exists LesNomsGscopeDeLOrganisme($Organisme)]} {
return [set LesNomsGscopeDeLOrganisme($Organisme)]
}
if {[info exists LesNomsGscopeDeLOrganisme("EstCharge")]} { return {} }
foreach FichierMiniConfig [glob "$RepertoireDuGenome/../*/beton/miniconfig"] {
set NomGscope [file tail [file dirname [file dirname $FichierMiniConfig]]]
if {[regexp -nocase {^Old|Old$|^Hidden|Hidden$} $NomGscope]} { continue }
foreach Ligne [LesLignesDuFichier $FichierMiniConfig] {
if {[regexp "^NotreOS " $Ligne]} {
scan $Ligne "%s %s %s" Bidon Genre Espece
regsub {\.$} $Espece "" Espece
set OrganismeLu "$Genre $Espece"
lappend LesNomsGscopeDeLOrganisme($OrganismeLu) $NomGscope
break
}
}
}
set LesNomsGscopeDeLOrganisme("EstCharge") "EstCharge"
return [LesNomsGscopeDeLOrganisme $Organisme]
}
proc GenomeDu Nom {
global RepertoireDuGenome
global GenomeDu
regsub -all {[0-9]} $Nom "" Prefixe
if {[info exists GenomeDu($Prefixe)]} { return [set GenomeDu($Prefixe)] }
if {[regexp "^TRNA|^ARN|^GLIMMER" $Nom]} {
FaireLire "Desole. Je ne puis trouver le genome de $Nom."
return ""
}
if {[info exists GenomeDu("EstCharge")]} { return "" }
foreach FichierBornes [glob "/genomics/link/*/fiches/bornesdespabs"] {
set NomGscope [file tail [file dirname [file dirname $FichierBornes]]]
if {[regexp -nocase {^Old|Old$|^Hidden|Hidden$} $NomGscope]} { continue }
scan [PremiereLigneDuFichier $FichierBornes] "%s" NomLu
regsub -all {[0-9]} $NomLu "" PrefixeLu
regsub "/fiches/bornesdespabs" $FichierBornes "" Genome
lappend GenomeDu($PrefixeLu) $Genome
}
set GenomeDu("EstCharge") "EstCharge"
return [GenomeDu $Nom]
}
proc BornesDuPABDUnAutreGenome {Nom {Genome ""}} {
global RepertoireDuGenome
if {$Genome==""} { set Genome [lindex [GenomeDu $Nom] 0]}
if { ! [file exists $Genome]} {
set Genome "$RepertoireDuGenome/../$Genome"
}
set FichierBornes "$Genome/fiches/bornesdespabs"
if { ! [file exists $Genome]} { return "" }
foreach Ligne [LesLignesDuFichier $FichierBornes] {
if {[regexp "$Nom" $Ligne]} { return $Ligne }
}
return ""
}
proc CreateurDesPABs {{Dieu ""}} {
global RepertoireDuGenome
global CreateurDesPABs
set FichierCreateur "$RepertoireDuGenome/fiches/createurdespabs"
if {$Dieu==""} {
if {[info exists CreateurDesPABs]} { return $CreateurDesPABs }
if {[file exists $FichierCreateur]} {
set CreateurDesPABs [ContenuDuFichier $FichierCreateur]
} else {
set CreateurDesPABs "Inconnu"
}
return $CreateurDesPABs
}
set CreateurDesPABs $Dieu
Sauve $CreateurDesPABs dans $FichierCreateur
return $CreateurDesPABs
}
proc NarcisseDuFichier {Fichier {FichierSortie ""}} {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" Access
set Nar [Narcisse $Access]
if {$Nar==""} { set Nar [Narcisse $Access New] }
lappend Sortie $Nar
}
if {$FichierSortie==""} { set FichierSortie $Fichier.narcisse }
return [SauveLesLignes $Sortie dans $FichierSortie]
}
proc ACetDRdansTREMBL {} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/narcisse"] {
scan $Ligne "%s %s %s" Nom BanqueId Access
set Narcisse([string toupper $Access]) $Nom
set Narcisse($Nom) $Access
}
set F [open "/prot/trembl/sp_tr_nrdb/trembl.dat" "r"]
while {[gets $F Ligne]>=0} {
if {[regexp "^AC" $Ligne]} { set AC $Ligne }
if {[regexp "^OS" $Ligne]} { set OS $Ligne }
if {[regexp "^DR EMBL" $Ligne]} {
set DR $Ligne
if { ! [regexp "Pyrococcus abyssi" $OS]} { continue }
scan $DR "%s %s %s %s" a b c Access
if { ! [regexp -nocase {Cab[0-9][0-9][0-9][0-9][0-9]} $Ligne Access]} { continue }
scan $AC "%s %s" Bidon AC
regsub {;} $AC "" AC
set Nom "???????????????"
set ACCESS [string toupper $Access]
if {[info exists Narcisse($ACCESS)]} { set Nom [set Narcisse($ACCESS)] }
lappend Sortie "$Nom $Access $AC"
Espionne "$Nom $Access $AC"
}
}
SauveLesLignes $Sortie dans "$RepertoireDuGenome/fiches/narcisse-a-trois"
}
proc MonImageDansLaBanque Nom {
set BanqueId_Access [Narcisse $Nom]
set Access ""
scan $BanqueId_Access "%s %s" BanqueId Access
if {$BanqueId==""} { return "" }
if {$Access==""} { set Access $BanqueId }
return [join [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"] "\n"]
}
proc Narcisse {Nom {OldNewAll ""}} {
global RepertoireDuGenome
global ListeDesPABs
global Narcisse
set Nom [string toupper $Nom]
set NotreOS [NotreOS]
if {[regexp -nocase "All" $OldNewAll]} {
set OldNew ""
set AllNarcisse 1
} else {
set OldNew $OldNewAll
set AllNarcisse 0
}
Wup "First check for OldNew Access"
if {$OldNew!=""} {
if { [regexp -nocase "Old" $OldNew] } { set OldNew "Old" }
if { [regexp -nocase "New" $OldNew] } { set OldNew "New" }
if { [regexp -nocase "PAB" $OldNew] } { set OldNew "PAB" }
if {[info exists Narcisse($Nom,$OldNew)]} {
return [set Narcisse($Nom,$OldNew)]
}
if {[info exists Narcisse("EstCharge",$OldNew)]} { return "" }
set FichierNarcisseATrois "$RepertoireDuGenome/fiches/narcisse-a-trois"
if { ! [file exists $FichierNarcisseATrois]} {
set Narcisse("EstCharge",Old) "EstCharge"
set Narcisse("EstCharge",New) "EstCharge"
set Narcisse("EstCharge",PAB) "EstCharge"
return [Narcisse $Nom]
} else {
foreach Ligne [LesLignesDuFichier $FichierNarcisseATrois] {
scan $Ligne "%s %s %s" Moi Old New
set Narcisse($Moi,New) $New
set Narcisse($Moi,Old) $Old
set Narcisse($Old,New) $New
set Narcisse($New,Old) $Old
set Narcisse($Old,Old) $Moi
set Narcisse($New,New) $Moi
set Narcisse($Old,PAB) $Moi
set Narcisse($Moi,PAB) $Moi
set Narcisse($New) $Moi
set Narcisse($Old) $Moi
set Narcisse([string toupper $Moi],New) $New
set Narcisse([string toupper $Moi],Old) $Old
set Narcisse([string toupper $Old],New) $New
set Narcisse([string toupper $New],Old) $Old
set Narcisse([string toupper $New]) $Moi
set Narcisse([string toupper $Old]) $Moi
}
set Narcisse("EstCharge",New) "EstCharge"
set Narcisse("EstCharge",Old) "EstCharge"
set Narcisse("EstCharge",PAB) "EstCharge"
return [Narcisse $Nom $OldNew]
}
}
if {$AllNarcisse} {
Wup "Look in Narcisse all"
if {[info exists Narcisse($Nom,All)]} {
return [set Narcisse($Nom,All)]
}
if {[info exists Narcisse("EstCharge",All)]} {
if { [info exists Narcisse($Nom,New)]} { return [set Narcisse($Nom,New)] }
if { ! [info exists Narcisse("EstCharge",New)]} { return [Narcisse $Nom New] }
return [Narcisse $Nom]
}
Wup "Read the file narcisse all"
set FichierNarcisse "$RepertoireDuGenome/../narcisse"
if {[file exists $FichierNarcisse]} {
foreach Ligne [LesLignesDuFichier $FichierNarcisse] {
set Access ""
scan $Ligne "%s %s %s" NomLu BanqueId Access
if {$Access==""} { set Access $BanqueId }
set Narcisse($NomLu,All) "$Access"
set Narcisse($Access,All) "$NomLu"
set Narcisse([string toupper $NomLu],All) "$Access"
set Narcisse([string toupper $Access],All) "$NomLu"
}
set Narcisse("EstCharge",All) "EstCharge"
return [Narcisse $Nom All]
}
return [Narcisse $Nom]
}
Wup "Look in Narcisse"
if {[info exists Narcisse($Nom)]} {
return [set Narcisse($Nom)]
}
if {[info exists Narcisse("EstCharge")]} {
if { ! [info exists Narcisse("EstCharge",New)]} { return [Narcisse $Nom New] }
return ""
}
Wup "Read the file narcisse"
set FichierNarcisse "$RepertoireDuGenome/fiches/narcisse"
if {[file exists $FichierNarcisse]} {
foreach Ligne [LesLignesDuFichier $FichierNarcisse] {
set Access ""
scan $Ligne "%s %s %s" NomLu BanqueId Access
if { ! [regexp {\:} $BanqueId]} { set Access $BanqueId }
if {$Access==""} { set Access $BanqueId }
set Narcisse($NomLu) "$Access"
set Narcisse($Access) "$NomLu"
set Narcisse([string toupper $NomLu]) "$Access"
set Narcisse([string toupper $Access]) "$NomLu"
}
set Narcisse("EstCharge") "EstCharge"
if {[info exists Narcisse($Nom)]} {
return [set Narcisse($Nom)]
} else {
if {$Nom!="APPEND"} { return "" }
}
}
Wup "Create the file narcisse"
if {[OuiOuNon "Do I use DaedalusHits to create Narcisse ?"]} {
foreach PAB [ListeDesPABs] {
Espionne "PAB $PAB"
if {[info exists Narcisse($PAB)]} { continue }
set FichierDaedalus "$RepertoireDuGenome/daedalushits/$PAB"
if { ! [file exists $FichierDaedalus]} { continue }
set TaxId [OrganismeDuPAB $PAB TaxId]
if {$TaxId=="Inconnu inconnu"} { set TaxId "" }
Espionne "I'm looking for $TaxId in $FichierDaedalus"
catch {unset MeilleurPNTrouve}
set BonneLigne ""
foreach Ligne [LesLignesDuFichier $FichierDaedalus] {
set AC [ValeurDeLaBalise AC Ligne "NePasRogner"]
set PN [ValeurDeLaBalise PN Ligne "NePasRogner"]
set OX [ValeurDeLaBalise OX Ligne "NePasRogner"]
Espionne "$PAB $TaxId $AC $OX $PN"
if {$PN > 1.e-3} { break }
if {[EstUnAccessPDB $AC]} { continue }
if {[EstUnPAB $AC]} { continue }
if {$TaxId=="" && \
[OuiOuNon "Unfortunately the organism of $PAB is unknown\n\
Do I use the best blastp hit for Narcisse ?"]} {
set BonneLigne $Ligne ; break
}
set TexteOX "=[join $OX "="]="
if {[regexp "=$TaxId=" $TexteOX]} { set BonneLigne $Ligne ; break }
}
if {$BonneLigne==""} {
# FaireLire "I can't find an homolog for $PAB in apns/$PAB. I skipp it"
continue
}
AppendAuFichier $FichierNarcisse "$PAB $AC"
}
} elseif {[OuiOuNon "Do I use apns to create Narcisse ?"]} {
foreach PAB [ListeDesPABs] {
if {[info exists Narcisse($PAB)]} { continue }
set FichierAPNs "$RepertoireDuGenome/apns/$PAB"
if { ! [file exists $FichierAPNs]} { continue }
catch {unset MeilleurPNTrouve}
set BonneLigne ""
foreach Ligne [LesLignesDuFichier $FichierAPNs] {
Espionne $Ligne
scan $Ligne "%s %s %f" BanqueId Access PN
if {$PN > 1.e-3} { break }
if {[EstUnAccessPDB $BanqueId]} { continue }
if {[EstUnPAB $Access]} { continue }
if {$NotreOS=="Inconnu inconnu" && \
[OuiOuNonMemo "Unfortunately NotreOS is 'Inconnu inconnu'\n\
Do I use the best blastp hit for Narcisse ?"]} {
set BonneLigne $Ligne ; break
}
set Orga [OrgaDuAccess $Access Complet]
if {[regexp $NotreOS $Orga]} { set BonneLigne $Ligne ; break }
}
if {$BonneLigne==""} {
# FaireLire "I can't find an homolog for $PAB in apns/$PAB. I skipp it"
continue
}
scan $BonneLigne "%s %s %f" BanqueId Access PN
AppendAuFichier $FichierNarcisse "$PAB $BanqueId $Access"
}
}
if { ! [file exists $FichierNarcisse]} { Sauve "Narcisse empty" dans $FichierNarcisse }
if {$Nom=="APPEND"} { return "" }
return [Narcisse $Nom]
}
proc BootstrapPourTous {{NomATraiter ""} {nBootstraps 1000} } {
if {$NomATraiter == "" } {
set Liste [ListeDeBoites]
} else {
set Liste [list $NomATraiter]
}
set RepertoireMSF "[RepertoireDuGenome]/msf"
set RepertoireBootstrap "[RepertoireDuGenome]/bootstrap"
set MatriceDeSimilarite "[RepertoireDuGenome]/fiches/bootstrapmatrix"
File mkdir $RepertoireBootstrap
set Conserve 1
if {! $Conserve && [llength [glob -nocomplain "$RepertoireBootstrap/*"]] > 0} {
set Conserve [OuiOuNon "Should I keep the existing files in $RepertoireBootstrap"]
}
foreach Nom $Liste {
set FichierMSF "$RepertoireMSF/$Nom"
set FichierBootstrap "$RepertoireBootstrap/$Nom"
set Log "tmp.bootstrap.log"
if { ! [file exists $FichierMSF]} { continue }
if { $Conserve && [file exists $FichierBootstrap] } { continue }
exec bootstrap $FichierMSF $FichierBootstrap $MatriceDeSimilarite $Log $nBootstraps
}
}
proc RenommePABenABY SousRepertoire {
global RepertoireDuGenome
foreach Fichier [lsort [glob "$RepertoireDuGenome/../casimir/$SousRepertoire/PAB*"]] {
set NomPAB [file tail $Fichier]
regsub "PAB" $NomPAB "ABY" NomABY
set Nouveau {}
foreach Ligne [LesLignesDuFichier $Fichier] {
while {[regexp {PAB[0-9][0-9][0-9][0-9]} $Ligne PAB]} {
regsub "PAB" $PAB "ABY" ABY
regsub {PAB[0-9][0-9][0-9][0-9]} $Ligne $ABY Ligne
}
lappend Nouveau $Ligne
}
Espionne [SauveLesLignes $Nouveau dans "$RepertoireDuGenome/$SousRepertoire/$NomABY"]
}
}
proc BallastUnPAB {Nom {RepertoireDestination ""}} {
global RepertoireDuGenome
global RepertoireDeTravail
if {$RepertoireDestination==""} { set RepertoireDestination $RepertoireDeTravail }
set Query $Nom
set Fichier "$RepertoireDuGenome/blastp/$Nom"
set Destination [Ballast $Fichier $RepertoireDestination $Query]
return [ContenuDuFichier $Destination]
}
proc BallastUnBlastP {Fichier {RepertoireDestination ""}} {
global RepertoireDeTravail
if {$RepertoireDestination==""} { set RepertoireDestination $RepertoireDeTravail }
set Query [QueryDuFichierBlast $Fichier]
set Destination [Ballast $Fichier $RepertoireDestination $Query]
return [ContenuDuFichier $Destination]
}
proc Ballast {FichierBlastP {RepertoireDestination ""} {Query ""} {TexteSansFichier ""}} {
global RepertoireDuGenome
global OptionsBallastPourJulie
Wup "ATTENTION : Ballast puts BanqueId instead of Access so we change back if necessary"
set AvecAccessAuLieuDeBanqueId 1
set Nom [file tail $FichierBlastP]
if {$Query==""} { set Query $Nom }
Espionne "$Query $Nom $FichierBlastP"
if { $FichierBlastP==$Nom || ! [file exists $FichierBlastP]} {
set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"
}
if {$RepertoireDestination == ""} {
set RepertoireDestination "$RepertoireDuGenome/ballast"
}
if { ! [File isdirectory $RepertoireDestination]} {
File mkdir $RepertoireDestination
}
set Destination "$RepertoireDestination/$Nom"
set Message ""
set CommandeBallast "ballast \
-p $FichierBlastP \
-o $Destination \
-anchors \
-noext \
-queryname $Query"
if {[info exists OptionsBallastPourJulie]} {
append CommandeBallast " $OptionsBallastPourJulie"
}
Espionne $CommandeBallast
if {[catch {eval exec $CommandeBallast} Message]} {
if {[regexp -nocase "Segmentation fault" $Message]} {
Warne "Don't worry about this message ..."
Warne $Message
Warne "Don't worry about this message ... be happy."
return ""
}
if {[regexp -nocase "error" $Message]} {
Warne "Don't worry about this message ..."
Warne $Message
Warne "Don't worry about this message ... be happy."
return ""
}
Warne "Don't worry about this message ..."
Warne " Ballast failed with message on next line :"
Warne $Message
Warne "Don't worry about this message ... be happy."
return ""
}
if {[regexp -nocase " error" [join [LesPremieresLignesDuFichier $Destination 10]] "\n"]} {
Warne "Don't worry about this message ..."
Warne [join [LesPremieresLignesDuFichier $Destination 5] "\n"]
Warne "FATAL Error in Ballast Output"
Warne "Don't worry about this message ... be happy."
return ""
}
if {$AvecAccessAuLieuDeBanqueId} {
set FichierAPNs "$RepertoireDuGenome/apns/$Nom"
if {[file exists "$FichierAPNs"]} {
foreach Ligne [LesLignesDuFichier $FichierAPNs] {
set Access ""
scan $Ligne "%s %s" BanqueId Access
if { ! [regexp -nocase {[a-z_0-9]} $Access]} { continue }
set BanqueId [string toupper $BanqueId]
set AccessDuBanqueId($BanqueId) $Access
}
} else {
DecortiqueBlast $FichierBlastP "SansSeuilExpect" "SansLimiteDeNombre" \
Query lBanqueId lAccess lDE lProfil lPN
foreach BanqueId $lBanqueId Access $lAccess {
if {$Access=="mol:protein"} { set Access $BanqueId }
if { ! [regexp -nocase {[a-z_0-9]} $Access]} { continue }
set BanqueId [string toupper $BanqueId]
set AccessDuBanqueId($BanqueId) $Access
}
}
set FichierAnchors "$Destination.anchors"
foreach Ligne [LesLignesDuFichier $FichierAnchors] {
scan $Ligne "%s %s %s" seq nom BanqueIdOriginal
if {$seq == "seq:"} {
regsub {\|} $Ligne "_" Ligne
regsub {\|} $BanqueIdOriginal "_" BanqueIdOriginal
set BanqueId [string toupper $BanqueIdOriginal]
regsub "_" $BanqueId ":" BanqueId
if {[info exists AccessDuBanqueId($BanqueId)]} {
set Access [set AccessDuBanqueId($BanqueId)]
} else {
set Access $BanqueIdOriginal
}
set NouvelleLigne [SubstitueAvecBlancsDevant $Ligne $BanqueIdOriginal $Access]
lappend NouveauAnchors $NouvelleLigne
} else {
lappend NouveauAnchors $Ligne
}
}
Espionne $FichierAnchors
Espionne [SauveLesLignes $NouveauAnchors dans $FichierAnchors]
}
if { $TexteSansFichier != "TexteSansFichier"} {
return $Destination
} else {
set Texte [ContenuDuFichier $Destination]
File delete -force $Destination
foreach FichierBallastExt [glob -nocomplain "$Destination.*"] {
File delete -force $FichierBallastExt
}
return $Texte
}
}
proc RepriseDeVieuxPABs {{FichierBornesACreer ""}} {
global RepertoireDuGenome
if {$FichierBornesACreer==""} { set FichierBornesACreer "[Fiches]/bornesdespabs" }
while { ! [OuiOuNon "\
I need a file with all 'ORFnumber begin end orientation'\n \
. like 'PAB2205 1017846 1018601 R'\n\
or 'ORFnumber' (without begin end)\n\
OK ?"]} {
if {[OuiOuNon "Stop ?"]} { exit }
if {[OuiOuNon "Abort reading old ORFs ?"]} { return 0 }
}
set ControleSurADN [OuiOuNon "Do You wish that I use DNA to verify * in each ORF"]
set Fichier [ButineArborescence All]
if {$Fichier==""} {
if {[OuiOuNon "Stop ?"]} { exit } else { return 0 }
}
set OwnBorne [OuiOuNonMemo "Do I create my own begin end for each orf" 0]
set L 999
set D 100
set F [expr $D + $L]
set I 99
foreach Ligne [LesLignesDuFichier $Fichier] {
catch {unset Nom}
catch {unset Debut}
catch {unset Fin}
catch {unset Orient}
if {$OwnBorne} {
scan $Ligne "%s" Nom
set Debut $D
set Fin $F
set Orient "F"
set D [expr $F + $I]
set F [expr $D + $L]
set nLus 3
} else {
set nLus [scan $Ligne "%s %d %d %s" Nom Debut Fin Orient]
}
if {$nLus<3} {
if {[OuiOuNon "$Ligne \n I skip it ?"]} {
continue
} else {
if {[OuiOuNon "Stop and exit?"]} { exit }
if {[OuiOuNon "Stop scanning ?"]} { break }
if {[OuiOuNon "Skip this line ?"]} { continue }
return 0
}
}
if {$Debut < $Fin} {
set OrientCalcule "F"
set DebutCalcule $Debut
set FinCalcule $Fin
} else {
set OrientCalcule "R"
set DebutCalcule $Fin
set FinCalcule $Debut
}
if {$nLus==3} {
set Debut $DebutCalcule
set Fin $FinCalcule
set Orient $OrientCalcule
} else {
if {$Debut!=$DebutCalcule || $Fin!=$FinCalcule} {
FaireLire "$Ligne\nWhen Orientation is used I want that Begin < End ..."
if {[OuiOuNon "Stop and exit ?"]} { exit }
if {[OuiOuNon "Stop scanning ?"]} { break }
if {[OuiOuNon "Skip this line ?"]} { continue }
}
}
regsub -all {[^0-9]} $Nom "" sNumero
scan $sNumero "%d" Numero
set BeauNom [format "%s%4.4d" [PreFixe] $Numero]
if {$ControleSurADN} {
set SeqNuc [BoutADN $Debut $Fin $Orient]
set SeqPro [SeqNucToSeqPro $SeqNuc]
if {[regexp -nocase {\*} $SeqPro]} {
if {[regexp {[^\*]+\*$} $SeqPro]} {
if {$Orient=="F"} {
incr Fin -3
} else {
incr Debut 3
}
} else {
FaireLire "$Ligne\nContains *'s or other wrong characters in DNA"
if {[OuiOuNon "Stop and exit ?"]} { exit }
if {[OuiOuNon "Stop scanning ?"]} { break }
if {[OuiOuNon "Skip this line ?"]} { continue }
}
}
}
lappend LesBornes "$BeauNom $Debut $Fin $Orient"
}
set FichierCree [SauveLesLignes $LesBornes dans $FichierBornesACreer]
ChargeLesPABs
return 1
}
proc CreeLeFichierBornesDesPABs {} {
global RepertoireDuGenome
file mkdir "$RepertoireDuGenome/fiches"
set FichierBornes "$RepertoireDuGenome/fiches/bornesdespabs"
if {[file exists $FichierBornes]} { return 1 }
FaireLire "I will ask You how to determine the ORFs.\n\
So You have to choose between : \n\
- Glimmer\n\
- Gscope own calculation (ab initio)\n\
- already existing ORFs list\n\
- already known proteome (with or without DNA file)\n\
- from a GenBank file (with prots and DNA)\n\
- sequences from a Blast or MSF output."
if {[OuiOuNon "Should I use Glimmer to create the ORFs ?"]} {
Glimmer
SauveLesLignes [LesBornesDeGlimmer] dans $FichierBornes
CreateurDesPABs "Glimmer"
return 1
}
if {[OuiOuNon "Should I create the ORFs ab initio ?"]} {
if { ! [CreeLesPABsAbInitio]} { return 0 }
CreateurDesPABs "GscopeAbInitio"
return 1
}
if {[OuiOuNon "Could I use an old version of ORFs ... ?"]} {
if { ! [RepriseDeVieuxPABs]} { return 0 }
CreateurDesPABs "RepriseDeVieuxPABs"
return 1
}
if {[OuiOuNon "Could I use an existing proteome from a GenBank file (with Prot and DNA) ... ?"]} {
return [CreeLesPABsAvecGenBank]
}
if {[OuiOuNon "Could I use an existing proteome from a tfas file (with Prot with/without DNA) ... ?"]} {
return [CreeLesPABsAvecUnProteomeDansTFAs]
}
if {[OuiOuNon "Could I use an existing proteome ... ?"]} {
set FichierBornesProteome "$RepertoireDuGenome/fiches/bornesdespabs.proteome"
while { ! [file exists $FichierBornesProteome] } {
if {[OuiOuNon "Do I create $FichierBornesProteome"]} {
CreeLesPABsAvecUnProteomeEtADN
} else {
if {[OuiOuNon "Do I skip proteome scanning ?"]} { return 0 }
if {[OuiOuNon "Do I stop ?"]} { exit }
}
}
if {[OuiOuNon "Can I use \n $FichierBornesProteome\nas ORFs limits ?"]} {
File copy $FichierBornesProteome "$RepertoireDuGenome/fiches/bornesdespabs"
CreateurDesPABs "Proteome"
return 1
}
}
if {[OuiOuNon "Could I create ORFs from a Collection ... ?"]} {
if { ! [CreeBornesDesPABsPourUneCollection [ButineArborescence "FOF"]]} { return 0 }
CreateurDesPABs "Collection"
return 1
}
if {[OuiOuNon "Stop ?"]} { exit }
return 0
}
proc TRNAscanSE {} {
global RepertoireDuGenome
global FichierSequenceADN
File mkdir "$RepertoireDuGenome/trnadir"
set FichierTRNAscanSE "$RepertoireDuGenome/trnadir/tRNAscan-SE.out"
set Ordre "-G"
set OC [NotreOC]
if {[regexp -nocase "Archaea" $OC]} { set Ordre "-A" }
if {[regexp -nocase "Bacteria" $OC]} { set Ordre "-P" }
if {[regexp -nocase "Eukaryota" $OC]} { set Ordre "" }
set CommandeTRNAscanSE ""
while {$CommandeTRNAscanSE==""} {
set CommandeTRNAscanSE "tRNAscan-SE $Ordre -o $FichierTRNAscanSE $FichierSequenceADN"
set CommandeTRNAscanSE [Entre $CommandeTRNAscanSE]
if {$CommandeTRNAscanSE=="" && [OuiOuNon "Do I cancel TRNAscanSE ?"]} { return "" }
}
catch {eval exec $CommandeTRNAscanSE} Message
if { ! [file exists $FichierTRNAscanSE]} {
FaireLire "TRNAscanSE didn't run properly.\nMay be You forget to set the environment."
return 0
}
set FichierBornesDesTRNAs "$RepertoireDuGenome/fiches/bornesdestrnas"
while {[file exists $FichierBornesDesTRNAs]} {
if {[OuiOuNon "I have to calculate $FichierBornesDesTRNAs.\n\
Do I delete the old one ? (You can copy it before answer)"]} {
File delete -force $FichierBornesDesTRNAs
} else {
if {[OuiOuNon "Do I keep the old version ?"]} { break }
}
}
ChargeLesTRNAs
return 1
}
proc TBlastNPourTous {{Banque ""} {Liste ""}} {
global RepertoireDuGenome
if {$Banque==""} {
#rR 2016/01/24 j'ai introduit LocaliseTBlastNDatabase ...
set Banque "tblastndatabase"
set NomDeLaBanque [LocaliseTBlastNDataBase]
} else {
set NomDeLaBanque ""
if {$Banque == "human"} { set NomDeLaBanque "/catalog/blast/human" }
if {$Banque == "completegenomes"} { set NomDeLaBanque "$RepertoireDuGenome/banques/completegenomes" }
if {$Banque == "myself"} { set NomDeLaBanque "$RepertoireDuGenome/banques/MSoverlap"}
if {[regexp "/" $Banque]} { set NomDeLaBanque $Banque }
#rR je ne suis pas sûr que ce qui suit est réellement pris en compte car j'ai rajouté LocaliseTBlastNDataBase dans la commande !!!
while { ! [file exists "$NomDeLaBanque"] \
&& ! [file exists "$NomDeLaBanque.nal"] \
&& ! [file exists "$NomDeLaBanque.nhr"] } {
if {$NomDeLaBanque!="" && [OuiOuNon "Do You want to create the tblastn database $NomDeLaBanque"]} {
if {$Banque == "genomes"} {
CreationDuNalDesGenomesComplets "PleaseAsk" "PleaseAsk" "PleaseAsk"
}
continue
} else {
if {[OuiOuNon "Can You tell me where to find the blast database $Banque ?"]} {
set NomDeLaBanque [Entre "/genomics/link"]
continue
}
if {[OuiOuNon "Do I cancel ?"]} { return }
if {[OuiOuNon "Do I exit ?"]} { exit }
}
}
}
set Repertoire "$RepertoireDuGenome/tblastn_[file tail $NomDeLaBanque]"
Espionne $Repertoire
#rR 2016/02/11 j'ai introduit la possiblilité d'utiliser BlastParameters is dans le rep tblastn
set p "tblastn"
set v 100
set b $v
set K 0
set e 10.0
set F "T"
set d $NomDeLaBanque
set LesObliges " p i o d v b K e F "
set MoreOptions ""
foreach {Key Value} [BlastParameters $Repertoire] {
Espionne "$Key $Value"
regsub -- {^\-+} $Key "" Key
if {[regexp " $Key " $LesObliges]} {
set $Key $Value
} else {
append MoreOptions " -$Key $Value"
}
}
set CommandeTBlastN "blastall \
-p $p \
-i \$FichierTFA \
-o \$FichierBlast.encours \
-d $d \
-v $v \
-b $b \
-K $K \
-e $e \
-F $F"
Wup "To find the pseudo-gene use ungapped -g F"
if {0 && [regexp -nocase "human" $NomDeLaBanque]} { append CommandeTBlastN " -g F" }
if {[OuiOuNon "Do You want to edit the tBlastN command ?" 0]} {
set CommandeTBlastN [Entre $CommandeTBlastN]
if {$CommandeTBlastN==""} { return "" }
}
if { ! [file exists "$Repertoire"]} {
file mkdir $Repertoire
}
set TestExistence 1
set GardeTout 0
if {$Liste==""} { set Liste [ListeDeBoites] }
foreach Nom $Liste {
if {[regexp "GLIMMER|TRNA|ARN" $Nom]} { continue }
if {[Fantome $Nom]} { continue }
if {[PasTouche $Nom]} { continue }
set FichierTFA "$RepertoireDuGenome/prottfa/$Nom"
set FichierBlast "$Repertoire/$Nom"
if { ! [file exists $FichierTFA]} {
FinPasTouche $Nom
continue
}
if {$GardeTout && [file exists $FichierBlast] } {
FinPasTouche $Nom
continue
}
if { $TestExistence && [file exists $FichierBlast] } {
if {[OuiOuNon "Some tblastn file already exist.\nDo I replace all of them ?" 0]} {
set TestExistence 0
} else {
if {[OuiOuNon "Do I keep them ?"]} { set GardeTout 1 }
if {$GardeTout || [OuiOuNon "$FichierBlast exists.\nDo I keep it ?"]} {
FinPasTouche $Nom
continue
}
}
}
if {[catch {eval exec $CommandeTBlastN} Message]} {
Warne "Error in CommandeTBlastN\n$Message"
}
if {[file exists "$FichierBlast.encours"]} {
file rename -force "$FichierBlast.encours" $FichierBlast
}
Espionne $FichierBlast
FinPasTouche $Nom
}
}
proc BlastNPourTous {{Banque ""} {NomATraiter ""} {RepQuery ""} {Filtre ""} {NbProc ""}} {
global RepertoireDuGenome
global GardeToutBlastNPourTous
global TestExistenceBlastNPourTous
if {$Banque==""} { set Banque "human" }
if {$Filtre==""} { set Filtre "T" }
if {$NbProc==""} { set NbProc 1 }
if {$NomATraiter==""} {
set Liste [ListeDesPABs]
} elseif {[string equal -nocase $NomATraiter "AskForSubList"]} {
set Liste [SousListe [ListeDesPABs]]
} elseif {[llength $NomATraiter]>1} {
set Liste $NomATraiter
} else {
set Liste [list $NomATraiter]
}
# set NomDeLaBanque $Banque
set NomDeLaBanque "/catalog/blast/$Banque"
while { ! [file exists "$NomDeLaBanque.nhr"] && ! [file exists "$NomDeLaBanque.nal"]} {
set Possible "[RepertoireDuGenome]/banques/$Banque"
if {[file exists "$Possible.nhr"] || [file exists "$Possible.nal"]} {
if {[OuiOuNon "Do I use $Possible ?"]} {
set NomDeLaBanque $Possible
set Banque [file tail $NomDeLaBanque]
break
}
}
if {[OuiOuNon "The blastn database $NomDeLaBanque doesn't exist.\n \
Do I cancel BlastNPourTous ?"]} {
return ""
}
FaireLire "Please complete the full name of the blastn database"
set NomDeLaBanque [Entre "[RepertoireDuGenome]/"]
set Banque [file tail $NomDeLaBanque]
}
set Repertoire "$RepertoireDuGenome/blastn$Banque"
if { ! [file exists "$Repertoire"]} {
File mkdir $Repertoire
}
if {[OnTraiteDesCDNAs] && $Banque=="human" && ! [file exists "$RepertoireDuGenome/blastn"]} {
set Link "$RepertoireDuGenome/blastn"
if {[OuiOuNon "Do I create a link \n $Link -> \n $Repertoire\n ?"]} {
exec ln -s $Repertoire $Link
}
}
if { ! [file exists "$RepertoireDuGenome/nucmask"]} {
if {[OuiOuNon "Do You want to run RepeatMasker for all ?" 0]} {
RepeatMaskerForAll
}
}
Espionne $Repertoire
if {[info exists CommandeBlastNPourTous]} {
set CommandeBlast $CommandeBlastNPourTous
if {[info exists GardeToutBlastNPourTous]} {
set GardeTout $GardeToutBlastNPourTous
} else {
setGardeTout 0
}
if {[info exists TestExistenceBlastNPourTous]} {
set TestExistence $TestExistenceBlastNPourTous
} else {
set TestExistence 1
}
} else {
set GardeTout 0
set TestExistence 1
#rR 2017/07/10 j'ai introduit la possiblilité d'utiliser BlastParameters is dans le rep tblastn
set p "blastn"
set v 100
set b $v
set K 0
set e 10.0
set F "T"
set d $NomDeLaBanque
set LesObliges " p i o d v b K e F "
set MoreOptions ""
foreach {Key Value} [BlastParameters $Repertoire] {
Espionne "$Key $Value"
regsub -- {^\-+} $Key "" Key
if {[regexp " $Key " $LesObliges]} {
set $Key $Value
} else {
append MoreOptions " -$Key $Value"
}
}
if {$d==""} {
set BlastNDataBase [LocaliseBlastNDataBase $NomDeLaBanque]
if {$BlastNDataBase==""} { return "" }
set NomDeLaBanque $BlastNDataBase
}
set CommandeBlast "blastall \
-p $p \
-i \$FichierTFA \
-o \$FichierBlast.encours \
-d $d \
-v $v \
-b $b \
-K $K \
-e $e \
-F $F"
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 CommandeBlastNPourTous $CommandeBlast
set GardeToutBlastNPourTous $GardeTout
set TestExistenceBlastNPourTous $TestExistence
}
set TestLongueurMinimale [OnTraiteDesCDNAs]
set SeuilLongueur 9
foreach Nom $Liste {
if {[PasTouche $Nom]} { continue }
set FichierTFA ""
if {$RepQuery==""} {
set ListeDesReps [list \
"[RepertoireDuGenome]/nucMaskAndReMask" \
"[RepertoireDuGenome]/nucmask" \
"[RepertoireDuGenome]/nuctfa"]
} else {
set ListeDesReps $RepQuery
}
foreach Rep $ListeDesReps {
set FichierTFA "$Rep/$Nom"
if {[file exists $FichierTFA]} { break }
}
if { $FichierTFA=="" || ! [file exists $FichierTFA]} {
FinPasTouche $Nom
continue
}
set FichierBlast "$Repertoire/$Nom"
if {$TestLongueurMinimale} {
set LeTFA [LesLignesDuFichier $FichierTFA]
set Seq [join [lrange $LeTFA 1 end]]
regsub -all -nocase "N" $Seq "" SeqSansN
if {[string length $SeqSansN]<$SeuilLongueur} {
FinPasTouche $Nom
continue
}
}
if {$GardeTout && [file exists $FichierBlast] } {
FinPasTouche $Nom
continue
}
if { $TestExistence && [file exists $FichierBlast] } {
if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
FinPasTouche $Nom
continue
}
}
Espionne "Je vais lancer blastn sur $FichierBlast"
if {[catch {eval exec $CommandeBlast} Message]} {
Espionne "Problem with $FichierBlast"
Espionne $Message
}
if {[file exists "${FichierBlast}.encours"]} {
CorrectionPourVarsplicDuBlastP "${FichierBlast}.encours"
file rename -force "${FichierBlast}.encours" $FichierBlast
} else {
Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
}
FinPasTouche $Nom
}
}
proc BlastXDesTROUsPourTous {{NomATraiter ""}} {
global RepertoireDuGenome
set BlastXDataBase "/catalog/blast/protall"
set RepTROUs "$RepertoireDuGenome/nuctfa"
set Repertoire "$RepertoireDuGenome/trousblastx"
if { ! [file exists "$Repertoire"]} {
File mkdir $Repertoire
}
if {$NomATraiter == ""} {
set Liste [ListeDesTROUs]
} else {
set Liste [list $NomATraiter]
}
set CommandeBlast "blastall \
-p blastx \
-i \$FichierTFA \
-o \$FichierBlast.encours \
-d $BlastXDataBase \
-v 100 \
-b 100 "
if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
set CommandeBlast [Entre $CommandeBlast]
if {$CommandeBlast==""} { return "" }
}
foreach Nom $Liste {
set FichierTFA "$RepTROUs/$Nom"
if { ! [file exists "$FichierTFA"]} { continue }
set FichierBlast "$Repertoire/$Nom"
if {[file exists $FichierBlast] } { continue }
if {[PasTouche $Nom]} { continue }
Espionne "Je vais lancer BlastX \n de $FichierTFA \nsur $BlastXDataBase \nresultat dans $FichierBlast"
if {[catch {eval exec $CommandeBlast} Message]} {
Espionne "Problem with $FichierBlast"
Espionne $Message
}
if {[file exists "${FichierBlast}.encours"]} {
file rename -force "${FichierBlast}.encours" $FichierBlast
} else {
Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
}
FinPasTouche $Nom
}
}
proc TBlastXPourTous {{NomATraiter ""} {Banque ""}} {
global RepertoireDuGenome
if {$Banque==""} {
set TBlastXDataBase "/catalog/blast/genembl"
} else {
if {[regexp "/" $Banque]} {
set TBlastXDataBase $Banque
} else {
set TBlastXDataBase "/catalog/blast/$Banque"
}
}
set RepFileMask "$RepertoireDuGenome/nucmask"
set Queue [file tail $TBlastXDataBase]
regsub {\.[^\.]+$} $Queue "" Queue
set Repertoire "$RepertoireDuGenome/tblastx$Queue"
if { ! [file exists "$Repertoire"]} {
File mkdir $Repertoire
}
if {$NomATraiter == ""} {
set Liste [ListeDesPABs]
} elseif {[llength $NomATraiter] > 1} {
set Liste $NomATraiter
} else {
set Liste [list $NomATraiter]
}
set CommandeBlast "blastall \
-p tblastx \
-i \$FichierTFA \
-o \$FichierBlast.encours \
-d $TBlastXDataBase \
-v 50 \
-b 50 "
if {[OuiOuNonMemo "Do You want to edit the Blast command ?" 0]} {
set CommandeBlast [Entre $CommandeBlast]
if {$CommandeBlast==""} { return "" }
}
set TestLongueurMinimale [OnTraiteDesCDNAs]
set SeuilLongueur 9
foreach Nom $Liste {
set FichierTFA ""
foreach Rep {nucMaskAndReMask nucmask nuctfa} {
set FichierTFA "$RepertoireDuGenome/$Rep/$Nom"
if {[file exists $FichierTFA]} { break }
}
if { $FichierTFA=="" || ! [file exists $FichierTFA]} {
Warne "$FichierTFA doesn't exist."
continue
}
set FichierBlast "$Repertoire/$Nom"
if {$TestLongueurMinimale} {
set LeTFA [LesLignesDuFichier $FichierTFA]
set Seq [join [lrange $LeTFA 1 end]]
regsub -all -nocase "N" $Seq "" SeqSansN
if {[string length $SeqSansN]<$SeuilLongueur} { continue }
}
if {[file exists $FichierBlast] } { continue }
if {[PasTouche $Nom]} { continue }
Espionne "Je vais lancer TBlastX de $FichierTFA"
if {[catch {eval exec $CommandeBlast} Message]} {
Espionne "Problem with $FichierBlast"
Espionne $Message
}
if {[file exists "${FichierBlast}.encours"]} {
file rename -force "${FichierBlast}.encours" $FichierBlast
} else {
Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
}
FinPasTouche $Nom
}
}
proc BlastXPourTous {{NomATraiter ""} {Banque ""}} {
global RepertoireDuGenome
if {$Banque==""} {
set BlastXDataBase "/catalog/blast/protall"
} else {
if {[regexp "/" $Banque]} {
set BlastXDataBase $Banque
} else {
set BlastXDataBase "/catalog/blast/$Banque"
}
}
set RepFileMask "$RepertoireDuGenome/nucmask"
set Repertoire "$RepertoireDuGenome/blastx"
if { ! [file exists "$Repertoire"]} {
File mkdir $Repertoire
}
if {$NomATraiter == ""} {
set Liste [ListeDesPABs]
} elseif {[llength $NomATraiter] > 1} {
set Liste $NomATraiter
} else {
set Liste [list $NomATraiter]
}
set CommandeBlast "blastall \
-p blastx \
-i \$FichierTFA \
-o \$FichierBlast.encours \
-d $BlastXDataBase \
-v 50 \
-b 50 "
if {[OuiOuNonMemo "Do You want to edit the Blast command ?" 0]} {
set CommandeBlast [Entre $CommandeBlast]
if {$CommandeBlast==""} { return "" }
}
set CommandeBlastXPourTous $CommandeBlast
set TestLongueurMinimale [OnTraiteDesCDNAs]
set SeuilLongueur 9
foreach Nom $Liste {
set FichierTFA ""
foreach Rep {nucMaskAndReMask nucmask nuctfa} {
set FichierTFA "$RepertoireDuGenome/$Rep/$Nom"
if {[file exists $FichierTFA]} { break }
}
if { $FichierTFA=="" || ! [file exists $FichierTFA]} {
Warne "$FichierTFA doesn't exist."
continue
}
set FichierBlast "$Repertoire/$Nom"
if {$TestLongueurMinimale} {
set LeTFA [LesLignesDuFichier $FichierTFA]
set Seq [join [lrange $LeTFA 1 end]]
regsub -all -nocase "N" $Seq "" SeqSansN
if {[string length $SeqSansN]<$SeuilLongueur} { continue }
}
if {[file exists $FichierBlast] } { continue }
if {[PasTouche $Nom]} { continue }
Espionne "Je vais lancer BlastX de $FichierTFA"
if {[catch {eval exec $CommandeBlast} Message]} {
Espionne "Problem with $FichierBlast"
Espionne $Message
}
if {[file exists "${FichierBlast}.encours"]} {
file rename -force "${FichierBlast}.encours" $FichierBlast
} else {
Espionne "${FichierBlast}.encours doesn't exist ... bouhouhouhou !"
}
FinPasTouche $Nom
}
}
proc BlastParameters {{Rep ""}} {
if {$Rep==""} { set Rep "blastp" }
if {[regexp "/" $Rep]} {
set ParametersFile "$Rep/BlastParameters.txt"
} else {
set ParametersFile "[RepertoireDuGenome]/$Rep/BlastParameters.txt"
}
if {[FileAbsent $ParametersFile]} { return {} }
set LesKV {}
foreach Ligne [LesLignesDuFichier $ParametersFile] {
if {[regexp {^\#} $Ligne]} { continue }
regsub RepertoireDuGenome $Ligne [RepertoireDuGenome] Ligne
scan $Ligne "%s %s" K V
regsub -- {^\-+} $K "" K
lappend LesKV "-$K" $V
}
return $LesKV
}
proc BlastPPourTous {{NomATraiter ""} {Banque ""} {AvecPasTouche ""} {Expect ""} {Vparam ""} {Bparam ""}} {
global RepertoireDuGenome
global CommandeBlastPPourTous
global GardeToutBlastPPourTous
global TestExistenceBlastPPourTous
JeMeSignale
set Extension [file tail $Banque]
if {$Expect==""} { set Expect 10 }
if {$AvecPasTouche==""} { set AvecPasTouche "AvecPasTouche" }
set AvecPasTouche [string equal -nocase $AvecPasTouche "AvecPasTouche"]
if {$NomATraiter=="" || $NomATraiter=="All"} {
set NomATraiter ""
set Liste [ListeDesPABs]
} elseif {[regexp "," $NomATraiter]} {
set Liste [split $NomATraiter ","]
} elseif {[llength $NomATraiter] > 1} {
set Liste $NomATraiter
} elseif {$NomATraiter=="ListeDesFusions"} {
set Liste [ListeDesFusions]
} else {
if {[EstUnPAB $NomATraiter]} { set AvecPasTouche 0 }
set Liste [list $NomATraiter]
}
set Repertoire "$RepertoireDuGenome/blastp$Extension"
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 $Banque]
set V 250
set B $V
if {[regexp "protall" $BlastPDataBase]} { set V 500; set B 500 } ;#rR attention BlastPDatabase peut etre remplacé pas BlastParameters
if {[OnTraite "CilioCarta"]} { set V 1000; set B $V }
if {[OnTraite "CilioCode"]} { set V 1000; set B $V }
if {[OnTraite "TTLL"]} { set V 2000; set B $V }
if {$Vparam!=""} { set V $Vparam }
if {$Bparam!=""} { set B $Bparam }
set p "blastp"
set v $V
set K 0
set b $B
set e $Expect
set F "T"
set d $BlastPDataBase
set LesObliges " p i o d v b K e F "
set MoreOptions ""
foreach {Key Value} [BlastParameters] {
regsub -- {^\-+} $Key "" Key
if {[regexp " $Key " $LesObliges]} {
set $Key $Value
} else {
append MoreOptions " -$Key $Value"
}
}
if {$d==""} { return "" } ;#rR je l'ai déplacé de la haut pour qu'il soit pris en compte
set CommandeBlast "blastall \
-p $p \
-i \$FichierTFA \
-o \$FichierBlast.encours \
-d $d \
-v $v \
-b $b \
-K 0 \
-e $e \
-F $F \
$MoreOptions"
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
}
set FichierBlast ""
foreach Nom $Liste {
set NomOrigine $Nom
set Nom [file tail $Nom]
if {$AvecPasTouche && [PasTouche $Nom]} { continue }
if {[EstUnPAB $Nom]} {
set FichierTFA "$RepertoireDuGenome/prottfa/$Nom"
set FichierTFABest "$RepertoireDuGenome/prottfaBEST/$Nom"
if {[file exists $FichierTFABest]} {set FichierTFA $FichierTFABest}
} else {
set FichierTFA $NomOrigine
if { ! [file exists $FichierTFA]} { set FichierTFA "$NomOrigine.tfa" }
}
set FichierBlast "$Repertoire/$Nom"
if { ! [file exists $FichierTFA]} {
Warne "$FichierTFA does'nt exist."
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
if {$GardeTout && [file exists $FichierBlast] } {
Espionne "$Nom already done"
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
if { $TestExistence && [file exists $FichierBlast] } {
if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
}
if {[set Dedicated [DedicatedBlastDatabase]]!=""} {
set BanqueDedicated "[RepertoireDuGenome]/$Dedicated"
set MaBanque "$BanqueDedicated/$Nom-plus"
Espionne $BanqueDedicated
if {[FileAbsent $MaBanque]} {
set General [file tail $BlastPDataBase]
lappend LeTexte "TITLE $General and $BanqueDedicated for $Nom"
lappend LeTexte "DBLIST $BlastPDataBase $BanqueDedicated/$Nom"
SauveLesLignes $LeTexte dans $MaBanque.pal
}
Espionne $MaBanque
Espionne $CommandeBlast
Espionne "-d $BlastPDataBase"
regsub -- "-d $BlastPDataBase " $CommandeBlast "-d $MaBanque " CommandeBlast
Espionne $CommandeBlast
}
catch {eval exec $CommandeBlast}
if {[file exists "$FichierBlast.encours"]} {
file rename -force "$FichierBlast.encours" $FichierBlast
}
if {$AvecPasTouche} { FinPasTouche $Nom }
Espionne $FichierBlast
}
DedicatedBlastDatabase "Reset"
return $FichierBlast
}
proc PsiBlastPPourTous {{NomATraiter ""} {PsiBlastPDataBase ""}} {
global RepertoireDuGenome
global CommandePsiBlastPPourTous
global GardeToutPsiBlastPPourTous
global TestExistenceBlastPPourTous
JeMeSignale
set AvecPasTouche 1
if {$NomATraiter == ""} {
set Liste [ListeDesPABs]
} elseif {[llength $NomATraiter] > 1} {
set Liste $NomATraiter
} elseif {$NomATraiter=="ListeDesFusions"} {
set Liste [ListeDesFusions]
} else {
if {[EstUnPAB $NomATraiter]} { set AvecPasTouche 0 }
set Liste [list $NomATraiter]
}
set Repertoire "[RepertoireDuGenome]/psiblastp"
if { ! [file exists "$Repertoire"]} {
File mkdir $Repertoire
}
if {[info exists CommandePsiBlastPPourTous]} {
set CommandePsiBlast $CommandePsiBlastPPourTous
if {[info exists GardeToutPsiBlastPPourTous]} {
set GardeTout $GardeToutPsiBlastPPourTous
} else {
setGardeTout 0
}
if {[info exists TestExistencePsiBlastPPourTous]} {
set TestExistence $TestExistencePsiBlastPPourTous
} else {
set TestExistence 1
}
} else {
set GardeTout 0
set TestExistence 1
if {$PsiBlastPDataBase==""} {
set PsiBlastPDataBase [LocalisePsiBlastPDataBase]
}
if {$PsiBlastPDataBase==""} { return "" }
set j 2
set v 500
set b $v
set K 0
set e 10
set F "T"
set d $PsiBlastPDataBase
set LesObliges " i o d j v b K e F"
set MoreOptions ""
foreach {Key Value} [BlastParameters] {
regsub -- {^\-+} $Key "" Key
if {[regexp " $Key " $LesObliges]} {
set $Key $Value
} else {
append MoreOptions " -$Key $Value"
}
}
set CommandePsiBlast "blastpgp \
-i \$FichierTFA \
-o \$FichierPsiBlast.encours \
-d $d \
-j $j \
-v $v \
-b $b \
-K $K \
-e $e \
-F $F \
$MoreOptions"
if {[OuiOuNon "Do You want to edit the PsiBlast command ?" 0]} {
set CommandePsiBlast [Entre $CommandePsiBlast]
if {$CommandePsiBlast==""} { 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 CommandePsiBlastPPourTous $CommandePsiBlast
set GardeToutPsiBlastPPourTous $GardeTout
set TestExistencePsiBlastPPourTous $TestExistence
}
foreach Nom $Liste {
if {$AvecPasTouche && [PasTouche $Nom]} { continue }
set FichierTFA "$RepertoireDuGenome/prottfa/$Nom"
set FichierPsiBlast "$Repertoire/$Nom"
if { ! [file exists $FichierTFA]} {
Warne "$FichierTFA does'nt exist."
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
if {$GardeTout && [file exists $FichierPsiBlast] } {
Espionne "$Nom already done"
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
if { $TestExistence && [file exists $FichierPsiBlast] } {
if {[OuiOuNon "$FichierPsiBlast already exists\nDo I keep it ?"]} {
if {$AvecPasTouche} { FinPasTouche $Nom }
continue
}
}
catch {eval exec $CommandePsiBlast}
if {[file exists "$FichierPsiBlast.encours"]} {
file rename -force "$FichierPsiBlast.encours" $FichierPsiBlast
}
if {$AvecPasTouche} { FinPasTouche $Nom }
Espionne $FichierPsiBlast
}
}
proc CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBL {Nom Debut Fin Orient {GardeLesExistants 1}} {
global RepertoireDuGenome
global ADN TDN RAC
global LongueurADN DerniereBase
global DuProteome NucOui
set NotreOS [NotreOS]
set NotreOC [NotreOC]
set NotreOX [NotreOX]
if { ! [info exists ADN]} { ChargeADNetTDNetRAC }
if { ! [info exists DuProteome]} {
while {[file exists "$RepertoireDuGenome/proteometfa"]} {
if {[OuiOuNon "Do I keep the protein sequences from the proteome ?"]} {
set DuProteome 1
break
} else {
if {[OuiOuNon "Do You confirm that I forget the proteome ?"]} {
set DuProteome 0
break
}
if {[OuiOuNon "Do I skip sequence creation ?"]} { return 0 }
if {[OuiOuNon "Do I exit ?"]} { exit }
}
}
}
if { ! [info exists NucOui]} {
set NucOui [OuiOuNon "Do I create the nuc files ?"]
}
set LongN [expr $Fin - $Debut +1]
set LongP [expr $LongN/3]
if {$NucOui} {
set SeqNuc [BoutADN $Debut $Fin $Orient]
set SeqPro [SeqNucToSeqPro $SeqNuc]
}
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
set FichierProtTFA "$RepertoireDuGenome/prottfa/$Nom"
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierProtEMBL "$RepertoireDuGenome/protembl/$Nom"
if { $NucOui && (! $GardeLesExistants || ! [file exists "$FichierNucTFA"])} {
set NucTFA ">$Nom"
append NucTFA "\n[SequenceFormatBrut $SeqNuc]"
Espionne [Sauve $NucTFA dans "$FichierNucTFA"]
}
if { ! [regexp "ARN|TRNA" $Nom] && (! $GardeLesExistants || ! [file exists "$FichierProtTFA"])} {
if {[info exists DuProteome] && $DuProteome} {
regsub -nocase {[a-z_\.]*} $Nom "ORF" Orf
set FichierProteome "$RepertoireDuGenome/proteometfa/$Orf"
if {[file exists $FichierProteome]} {
set TFA [ContenuDuFichier $FichierProteome]
regsub -nocase {>[a-z0-9\._]+ } $TFA ">$Nom " TFA
Sauve $TFA dans $FichierProtTFA
}
} else {
set ProtTFA ">$Nom"
append ProtTFA "\n[SequenceFormatBrut $SeqPro]"
Espionne [Sauve $ProtTFA dans "$FichierProtTFA"]
}
}
if { $NucOui && (! $GardeLesExistants || ! [file exists "$FichierNucEMBL"])} {
set NucEMBL ""
append NucEMBL "ID $Nom PRELIMINARY; DNA; $LongN Bps."
append NucEMBL "\nAC $Nom"
append NucEMBL "\nOS $NotreOS."
append NucEMBL "\nOC $NotreOC"
append NucEMBL "\nOX $NotreOX"
append NucEMBL "\nCC -!- from $Debut to $Fin. Orientation $Orient"
append NucEMBL "\n[QueSequenceFormatEMBL $SeqNuc AvecSQ]"
Espionne [Sauve $NucEMBL dans "$FichierNucEMBL"]
}
if { ! [regexp "ARN|TRNA" $Nom] && (! $GardeLesExistants || ! [file exists "$FichierProtEMBL"])} {
set ProtEMBL ""
append ProtEMBL "ID $Nom PRELIMINARY; PRT; $LongP AA."
append ProtEMBL "\nAC $Nom"
append ProtEMBL "\nOS $NotreOS."
append ProtEMBL "\nOC $NotreOC"
append ProtEMBL "\nOC $NotreOX"
if {[info exists DuProteome] && $DuProteome} {
set Head [PremiereLigneDuFichier $FichierProtTFA]
regsub -nocase {>[a-z0-9\._]+ } $TFA ">$Nom " DE
append ProtEMBl "\nDE $DE"
set SeqBrute [QueLaSequence [ContenuDuFichier $FichierProtTFA]]
append ProtEMBl "\nCC -!- taken frome known proteome"
append ProtEMBL "\n[QueSequenceFormatEMBL $SeqBrute AvecSQ]"
} else {
append ProtEMBL "\nCC -!- from $Debut to $Fin. Orientation $Orient"
append ProtEMBL "\n[QueSequenceFormatEMBL $SeqPro AvecSQ]"
}
Espionne [Sauve $ProtEMBL dans "$FichierProtEMBL"]
}
}
proc CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBLAvecBornesDesPABsEtADN {} {
global RepertoireDuGenome
if { ! [OuiOuNon "Do I create the sequences in \n $RepertoireDuGenome/..."]} { return }
if { ! [file exists "$RepertoireDuGenome/nuctfa"]} {
File mkdir $RepertoireDuGenome/nuctfa
}
if { ! [file exists "$RepertoireDuGenome/prottfa"]} {
File mkdir $RepertoireDuGenome/prottfa
}
if { ! [file exists "$RepertoireDuGenome/nucembl"]} {
File mkdir $RepertoireDuGenome/nucembl
}
if { ! [file exists "$RepertoireDuGenome/protembl"]} {
File mkdir $RepertoireDuGenome/protembl
}
set GardeLesExistants [OuiOuNon "Do I keep existing files ?"]
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdespabs"] {
ExtraireDe $Ligne Nom Debut Fin Orient
CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBL $Nom $Debut $Fin $Orient $GardeLesExistants
}
}
proc CreeLesFichiersNucTFAetNucEMBLAvecBornesDesTRNAsEtADN {} {
global RepertoireDuGenome
if { ! [file exists "$RepertoireDuGenome/nuctfa"]} {
File mkdir $RepertoireDuGenome/nuctfa
}
if { ! [file exists "$RepertoireDuGenome/nucembl"]} {
File mkdir $RepertoireDuGenome/nucembl
}
set GardeLesExistants [OuiOuNon "Do I keep existing files ?"]
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdestrnas"] {
ExtraireDe $Ligne Nom Debut Fin Orient
CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBL $Nom $Debut $Fin $Orient $GardeLesExistants
}
}
proc CreeCompletTFAavecADN {{Extension ""}} {
global RepertoireDuGenome
global ADN TDN RAC
global FichierSequenceADN
set NotreOS [NotreOS]
if { $Extension!=""} { catch {unset ADN} ; catch {unset TDN} ; catch {unset RAC} }
if { ! [info exists ADN]} { ChargeADNetTDNetRAC $Extension}
set NomDeLaBete "$NotreOS"
regsub " " $NomDeLaBete "_" NomDeLaBete
regsub {\.} $NomDeLaBete "" NomDeLaBete
set Long [string length [string range $ADN 1 end]]
set Entete ">$NomDeLaBete Genome complet.$Extension $Long BP"
set Fichier [string tolower "$NomDeLaBete.tfa$Extension"]
set TFA [SequenceFormatBrut [string range $ADN 1 end]]
set NomDuFichierCompletTFA "$RepertoireDuGenome/beton/$Fichier"
set NomDuFichierCompletTFA [Sauve "$Entete\n$TFA" dans "$RepertoireDuGenome/beton/$Fichier"]
if {$Extension==""} {
set FichierMiniConfig "$RepertoireDuGenome/beton/miniconfig"
set LesNommes {}
foreach Ligne [LesLignesDuFichier "$FichierMiniConfig"] {
if { ! [regexp "FichierSequenceADN" $Ligne]} {
lappend LesNommes $Ligne
} else {
lappend LesNommes "FichierSequenceADN $NomDuFichierCompletTFA"
}
}
SauveLesLignes $LesNommes dans $FichierMiniConfig
set FichierSequenceADN $NomDuFichierCompletTFA
}
return $NomDuFichierCompletTFA
}
proc CreeADNetTDNetRACaPartirDuFichierTFA Fichier {
Wup "Create the flat files beton/adn beton/tdn beton/rac with the tfa file Fichier"
Wup " if Fichier ends with .pure it creates adn.pure tdn.pure rac.pure"
set DejaDemandeCodeDegenere 0
set AccepteCodeDegenere 0
set SequenceBrute ""
foreach Ligne [LesLignesDuFichier $Fichier] {
regsub " " $Ligne "" BelleLigne
if {[regexp -nocase {[^ATGCNX]} $BelleLigne]} {
if {[regexp "^>" $BelleLigne]} { continue }
if {[regexp -nocase {[^ATGCNXMKRSYWVHDB]} $BelleLigne]} {
if {[OuiOuNon "$Ligne\n shows to be illegal, Do I stop ?"]} { exit }
if {[OuiOuNon "Do I skipp ?"]} { continue }
} else {
if { ! $DejaDemandeCodeDegenere} {
set DejaDemandeCodeDegenere 1
set AccepteCodeDegenere [OuiOuNon "Do You accept the degenerated code (ATGCNXMKRSYWVHDB) ?"]} {
}
if { ! $AccepteCodeDegenere } {
if {[OuiOuNon "$Ligne\n shows to be illegal, Do I stop ?"]} { exit }
if {[OuiOuNon "Do I skipp ?"]} { continue }
}
}
}
append SequenceBrute [string toupper $BelleLigne]
}
if {[regexp "\.pure$" $Fichier]} {
CreeADNetTDNetRAC $SequenceBrute ".pure"
} else {
CreeADNetTDNetRAC $SequenceBrute
}
}
proc ChargeConfig {{Force ""}} {
global ConfigChargee
global SansCafeDesSciences
if {$Force=="" && [info exists ConfigChargee]} { return }
CommandesExecPossibles
RepertoireDuGenome
CurrentGenome
if { ! [info exists SansCafeDesSciences] || ! $SansCafeDesSciences } {
NommeLesFichiersForum
}
RepertoireDeTravail
ChargeMiniConfig $Force
LesOrganismesTresProches
LesGenomesComplets
# Glossaire "bidon" "Court"
# LesGenomesCompletsPourGlossaire
}
proc ChargeMiniConfig {{Force ""}} {
#rR Force rajouté 2016/01/07 ...... c'était débile avant, sans cela !!!
global RepertoireDuGenome
global CurrentGenome
global FichierMiniConfig
global FichierMiniConfigSansGenome
global VersionDeGscopeAuBigBang
global FichierSequenceADN
global PrefixeDesORFs
global FormatOrfNumbering
global LongueurMiniDesORFs
global NotreOS
global NotreOC
global NotreOX
global NotreOrga
global GenomeOuCollection
global MaquilleNon
global ConfigChargee
if {$Force!=""} {
set FichierMiniConfig "[RepertoireDuGenome]/beton/miniconfig"
}
if { ! [info exists FichierMiniConfig] || ! [file exists $FichierMiniConfig]} {
set FichierMiniConfig $FichierMiniConfigSansGenome
}
set MaquilleOui 0
set MaquilleNon 1
set GenomeOuCollection "Genome"
foreach Ligne [LesLignesDuFichier $FichierMiniConfig] {
if {[regexp "^#" $Ligne]} { continue }
if {[regexp "VersionDeGscopeAuBigBang" $Ligne]} {
scan $Ligne "%s %s" Toto VersionDeGscopeAuBigBang
}
if {[regexp "FichierSequenceADN" $Ligne]} {
scan $Ligne "%s %s" Toto FichierSequenceADN
}
if {[regexp "PrefixeDesORFs" $Ligne]} {
scan $Ligne "%s %s" Toto PrefixeDesORFs
}
if {[regexp "FormatOrfNumbering" $Ligne]} {
# Attention il etait jusqu'au 29/06/2009 dans fiches/format_orf_numbering."
# pour les nouveaux projets il sera pris ici en premier.
# mais le fichier est cree quand meme car on l'appelle FormatDesNumerosPourCollection
# dans CreeMiniConfig.
scan $Ligne "%s %s" Toto FormatOrfNumbering
}
if {[regexp "LongueurMiniDesORFs" $Ligne]} {
scan $Ligne "%s %d" Toto LongueurMiniDesORFs
}
if {[regexp "NotreOS" $Ligne]} {
regsub {\.} [string range $Ligne 8 end] "" NotreOS
set NotreOrga [Glossaire $NotreOS Court]
}
if {[regexp "NotreOC" $Ligne]} {
set NotreOC [string range $Ligne 8 end]
}
if {[regexp "NotreOX" $Ligne]} {
set NotreOX [string range $Ligne 8 end]
}
if {[regexp "GenomeOuCollection" $Ligne]} {
set GenomeOuCollection [string trim [string range $Ligne 19 end]]
}
if {[regexp "MaquilleOui" $Ligne]} {
scan $Ligne "%s %s" Bidon MaquilleOui
set MaquilleNon [expr ! $MaquilleOui]
}
}
if { ! [PourWscope] } { DialogPort }
set ConfigChargee 1
}
proc CreeLaBaseOuLaCollection {} {
global FichierMiniConfig
global GenomeOuCollection
if {[file exists "$FichierMiniConfig"]} { ChargeMiniConfig }
if { [OnTraiteUnGenome] } {
CreeLaBase
} else {
CreeLaCollection
}
}
proc CreeFichierMiniConfig {{MiniConfigOrPrefixe ""} {OrfNumbering ""} {CollectionType ""} {OS ""} {OC ""} {OX ""} {RepGen ""}} {
JeMeSignale
#rR Attention j'ai rajouté RepGen pour pouvoir le faire pour un autre RepGen
global RepertoireDuGenome
global CurrentGenome
global FichierMiniConfig
global VersionDeGscopeAuBigBang
global FichierSequenceADN
global PrefixeDesORFs
global LongueurMiniDesORFs
global GenomeOuCollection
global NarcisseDuAlias
if {[regexp {%?([0-9]+)(\.[0-9]+d)?$} $OrfNumbering Match ON]} { set $OrfNumbering $ON }
set Prefixe $MiniConfigOrPrefixe
if {[regexp "," $MiniConfigOrPrefixe]} {
set OS ""
set OC ""
set OX ""
set RepGen ""
lassign [split $MiniConfigOrPrefixe ","] Prefixe OrfNumbering CollectionType OS OC OX RepGen
}
if {$RepGen==""} {
set RepGen [RepertoireDuGenome]
set YaDuNeuf [expr ![string equal $Prefixe ""]]
} else {
set YaDuNeuf 0
}
set FichierMiniConfigACreer "$RepGen/beton/miniconfig"
file mkdir "$RepGen/beton"
if {[regexp {^[0-9]+$} $OS]} { set OX $OS; set OS "" }
set OS [Tax $OS Name]
if {$OX!="" && $OS=="" } { set OS [Tax $OX Name] }
if {$OX==""} { set OX [Tax $OS TaxId] }
if {$OC==""} { set OC [TaxClass $OX Name] }
regsub -all "_" $OS " " OS
regsub -all "_" $OC " " OC
if {[info exists FichierMiniConfigACreer] && [file exists $FichierMiniConfigACreer]} {
if { ! $YaDuNeuf} { return $FichierMiniConfigACreer }
if {1 || [OuiOuNon "Do we overwrite $FichierMiniConfigACreer"]} {
Garde $FichierMiniConfigACreer "AndDelete"
}
}
set Interactif [expr !$YaDuNeuf]
set VersionDeGscopeAuBigBang "VersionDeGscopeAuBigBang [VersionDeGscope]"
set TFA [lindex [glob -nocomplain "$RepGen/beton/*.tfa"] 0]
set FichierSequenceADN "FichierSequenceADN $TFA"
if {$Prefixe!=""} {
set PrefixeDesORFs $Prefixe
} else {
set Interactif 1
set PrefixeDesORFs [Entre "PrefixeDesORFs BOX"]
}
regsub { *PrefixeDesORFs *} $PrefixeDesORFs "" P
set PrefixeDesORFs "PrefixeDesORFs $P"
set FormatOrfNumbering [FormatDesNumerosPourCollection $OrfNumbering]
set TextFormatOrfNumbering "FormatOrfNumbering $FormatOrfNumbering"
set LongueurMiniDesORFs "LongueurMiniDesORFs 0"
set GenomeOuCollection "GenomeOuCollection Collection"
if {$OS!=""} {
NotreOS $OS
if {$OC!=""} {
NotreOC $OC
} else {
set OC [NotreOC]
}
if {$OX!=""} {
NotreOX $OX
} else {
set OX [NotreOX]
}
set TexteNotreOS "NotreOS $OS"
set TexteNotreOC "NotreOC $OC"
set TexteNotreOX "NotreOX $OX"
} else {
set Interactif 1
if {[OuiOuNon "Do this collection concern only one organism ?" 0]} {
set OS [Entre "Homo sapiens"]
if {$OS==""} { set OS "Inconnu inconnu" }
while {$OS=="Inconnu inconnu" || [Glossaire $OS Complet]!=$OS} {
FaireLire "Sorry I don't know the organism $OS"
scan [MontreOrganismes "AvecRetour"] "%s %s %s" Orga Genre Espece
set OS "$Genre $Espece"
Espionne $OS
}
set OC [Entre [NotreOC $OS]]
set OX [NotreOX]
set TexteNotreOS "NotreOS $OS"
set TexteNotreOC "NotreOC $OC"
set TexteNotreOX "NotreOX $OX"
} else {
set TexteNotreOS "NotreOS Inconnu inconnu"
set TexteNotreOC "NotreOC ClassUnknown"
set TexteNotreOX "NotreOX 0"
}
}
if {$CollectionType==""} {
set Interactif 1
FaireLire "Please tell me what kind of collection you want to create.\n\
To each one corresponds a specific analysis."
set LeChoix [list \
"DNA" "DNA simple analysis (blastn, blastx, etc.)" \
"" "" \
"Prot" "Prot: Protein for blastp tblastn etc." \
"CDS" "CDS: DNA coding for a protein ( with correct frame )" \
"CDSProt" "Both: DNA coding for a protein ( with correct frame ) AND protein sequence" \
"CDSProtFoF" "Both: DNA coding for a protein ( with correct frame ) AND protein sequence in a FoF" \
"" "" \
"EukProt" "Eukaryotic Prot full analysis (loc, prot search, ontology...) " \
"EukDNA" "Eukaryotic cDNA full analysis (loc, prot search, ontology...) " \
"EukDNAAffy" "Eukaryotic cDNA full analysis (loc, prot search, ontology...) from Affymetrix" \
]
foreach {Clef Texte} $LeChoix {
lappend LesClefs $Clef
lappend LesTextes $Texte
}
set Clef ""
while {$Clef==""} {
set Clef [ChoixParmiJoli $LesClefs "" $LesTextes]
if {$Clef!=""} { break }
Boum
}
} else {
set Clef $CollectionType
}
switch $Clef {
"DNA" { set GenomeOuCollection "GenomeOuCollection Collection of DNA" }
"Prot" { set GenomeOuCollection "GenomeOuCollection Collection of proteins" }
"CDS" { set GenomeOuCollection "GenomeOuCollection Collection of CDS" }
"CDSProt" { set GenomeOuCollection "GenomeOuCollection Collection of CDS with protein" }
"CDSProtFoF" { set GenomeOuCollection "GenomeOuCollection Collection of CDS with protein in a FoF" }
"EukDNA" { set GenomeOuCollection "GenomeOuCollection Collection of cDNA" }
"EukDNAAffy" { set GenomeOuCollection "GenomeOuCollection Collection of cDNA from Affymetrix" }
default { set GenomeOuCollection $Clef }
}
set LaConfig {}
lappend LaConfig "#MiniConfig "
lappend LaConfig "$FichierSequenceADN"
lappend LaConfig "$VersionDeGscopeAuBigBang"
lappend LaConfig "$PrefixeDesORFs"
lappend LaConfig "$TextFormatOrfNumbering"
lappend LaConfig "$LongueurMiniDesORFs"
lappend LaConfig "$TexteNotreOS"
lappend LaConfig "$TexteNotreOC"
lappend LaConfig "$TexteNotreOX"
lappend LaConfig "$GenomeOuCollection"
set Config [join $LaConfig "\n"]
if {$Interactif && ! [OuiOuNon "OK to save following miniconfig ?\n\n$Config" ]} { Boum }
Sauve $Config dans $FichierMiniConfigACreer
return $FichierMiniConfigACreer
}
proc CreeLaCollection {{CollectionType ""} {SequenceSourceFile ""} {MiniConfig ""} {KeepEntete ""} {CreateNarcisse ""} {ForceAccessFirst ""}} {
JeMeSignale
global RepertoireDuGenome
global CurrentGenome
global FichierMiniConfig
global VersionDeGscopeAuBigBang
global FichierSequenceADN
global PrefixeDesORFs
global LongueurMiniDesORFs
global GenomeOuCollection
global NarcisseDuAlias
set LesRepertoiresNecessaires [list "beton" "fiches" "infos"]
foreach Rep $LesRepertoiresNecessaires {
file mkdir "$RepertoireDuGenome/$Rep"
}
set FichierMiniConfig [CreeFichierMiniConfig $MiniConfig]
Espionne $FichierMiniConfig
ChargeMiniConfig
LesOrganismesTresProches
PasTouche Check
#rR Avec les quelques lignes qui suivent on peut creer bornesdespabs automatiquement
if {$CollectionType=="AAD" || $CollectionType=="BAAD"} {
set FileOfFilename [CreeProteomeAvecUneListeAccessAliasDefinition $SequenceSourceFile $CollectionType]
set Coll [CreeLaCollection "FOF" $FileOfFilename]
if {[PourWscope]} { return [GuideMoi] } else { return $Coll }
}
if {$CollectionType=="FOF"} {
CreeBornesDesPABsPourUneCollection $SequenceSourceFile
set Coll [CreeLaCollection]
if {[PourWscope]} { return [GuideMoi] } else { return $Coll }
}
if {$CollectionType=="TFA"} {
CreeBornesDesPABsAvecTFAs $SequenceSourceFile $KeepEntete $CreateNarcisse $ForceAccessFirst
set Coll [CreeLaCollection]
if {[PourWscope]} { return [GuideMoi] } else { return $Coll }
}
#rR Voila, la creation automatique de bornesdespabs est faite
Espionne coucou
if {0 && [FileAbsent "[RepertoireDuGenome]/fiches/bornesdespabs]"] && [OnTraiteDesCDSProtFoF]} {
Espionne salut
CreateGscopeDatabaseForCDSProtFoF
exit
}
if {[OnTraiteDesClones] && ! [OnTraiteDesCDS]} {
GestionDesClones
exit
}
if {[OnTraiteDesCDNAs] && [OuiOuNon "Do I run LaTotalePourLesCDNAs ?"]} {
LaTotalePourLesCDNAs
exit
}
if {[file exists "$RepertoireDuGenome/fiches/bornesdespabs"] && \
! [OnTraiteSM2PH] && \
[OuiOuNon "Do you want to add a new sequence using the SeqIn procedure ?" 0]} {
return [UneNouvelleSequencePourGscope]
}
set QuestionDidYouAddNew "Did You add new elements to the collection ?"
while { ! [file exists "$RepertoireDuGenome/fiches/bornesdespabs"] \
|| [OuiOuNon $QuestionDidYouAddNew 0] \
|| [OuiOuNon "Do You want that I process a file with Access or FOF ?" 0] } {
set QuestionDidYouAddNew "Once again,\n\
Did You add new elements to the collection ? \n\
Normally you answer NO"
set Queue [file tail [RepertoireDuGenome]]
set Possible "[RepertoireDuGenome]/$Queue.fof"
if {[file exists $Possible]} {
set FichierFOFDefaut $Possible
} else {
set FichierFOFDefaut [RepertoireDuGenome]
}
set FichierFOF $FichierFOFDefaut
set AskForFOF 1
FaireLire "Please help me to find your sequences"
if {[OuiOuNon "Do You have a file with lines like (it can be mixed)\
\nAccess \
\nAccess Alias \
\nAccess Alias Definition \
\n or
\nBanqueId Access \
\nBanqueId Access Alias \
\nBanqueId Access Alias Definition \
\n or
\nhttp://uniprot.org/uniprot/P12345.txt \
\nhttp://uniprot.org/uniprot/P12345.txt Alias\
\n \
\n for example \
\nSW:ANDR_RAT P15207 AR Androgen receptor (Dihydrotestosterone receptor)
\n to collect the ORFs?"]} {
set FichierAccessAlias [ButineArborescence "All" $RepertoireDuGenome]
set FichierFOF [CreeProteomeAvecUneListeAccessAliasDefinition $FichierAccessAlias]
if {$FichierFOF!=""} { set AskForFOF 0 }
}
if {$FichierFOF==""} { set FichierFOF $FichierFOFDefaut }
if {[OuiOuNon "Do you want to create a proteome from OrthoInspector" 0]} {
while {[OiDomain "Ask"]=="" && [OuiOuNon "Do I exit ?"]} { exit }
file mkdir "[RepertoireDuGenome]/banques"
OiSplit
FaireLire "Please verify that banques/blastpdatabase links to \n/blast/OrthoInspector/Oi[OiDomain]\nand this database is online.\nThen run gscope Blastong ;)"
exit
}
if { ! $AskForFOF || \
[OuiOuNon "Do you have a file of filenames with Filename\nFileName\n or \nAlias FileName\nAlias FileName\n...\n ?"]} {
CreeBornesDesPABsPourUneCollection [ButineArborescence "FOF" $FichierFOF]
} elseif {[OuiOuNon "Do you have a file with all sequences in FASTA format in one file ?"]} {
CreeBornesDesPABsAvecTFAs
} elseif {[OuiOuNon "Do you want to use an existing ORF list ?\
\n From an other Gscope project ... or\
\n From Glimmer\
\n From a GenBank File\
\n etc."]} {
CreeLeFichierBornesDesPABs
}
set FichierNarcisse "$RepertoireDuGenome/fiches/narcisse"
if {[info exists NarcisseDuAlias] && ! [file exists $FichierNarcisse]} {
if {[OuiOuNon "Can I use NarcisseDuAlias to create Narcisse ?" 0]} {
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
}
}
}
}
if {[OnTraiteUneCollection]} {
if {[OuiOuNon "Do I collect the mRNA sequences corresponding to proteins ?" 0]} {
CollectionDeNucAPartirDeProtTFAPourTous
exit
}
}
if { ! [OnTraiteSM2PH] && [OuiOuNon "Do I complete the basic data for of each Gene \n\
(sequence, blastp, dbclustal)?" ]} {
set RepMSF "$RepertoireDuGenome/msf"
set RepBlastP "$RepertoireDuGenome/blastp"
set RepTBlastN "$RepertoireDuGenome/tblastngenomes"
set RepVer "$RepertoireDuGenome/ver"
set RepProtTFA "$RepertoireDuGenome/prottfa"
set RepProtEMBL "$RepertoireDuGenome/protembl"
set RepNucTFA "$RepertoireDuGenome/nuctfa"
set RepNucEMBL "$RepertoireDuGenome/nucembl"
foreach Rep [list $RepMSF $RepBlastP $RepVer $RepProtTFA $RepProtEMBL $RepNucTFA $RepNucEMBL] {
if {[file exists $Rep]} { continue }
File mkdir $Rep
}
set SeqOnly [OuiOuNon "Do I create ONLY sequences ?"]
if {[OnTraiteDesProteines]} {
set NucOnly 0
} else {
set NucOnly [OuiOuNonMemo "Do I create only NUCLEIC sequences (no translation to protein) ?"]
}
foreach Nom [ListeDesPABs] {
Espionne "Traitement $Nom"
if {[PasTouche $Nom]} { continue }
set FiMSF "$RepMSF/$Nom"
set FiBla "$RepBlastP/$Nom"
set FiTBN "$RepTBlastN/$Nom"
set FiVer "$RepVer/$Nom"
set FiProtEMBL "$RepProtEMBL/$Nom"
set FiProtTFA "$RepProtTFA/$Nom"
set FiNucEMBL "$RepNucEMBL/$Nom"
set FiNucTFA "$RepNucTFA/$Nom"
set Encore 1
set GN ""
while {$Encore} {
if { $SeqOnly } {
if {[file exists $FiProtTFA]} { break }
if {$NucOnly && [file exists $FiNucTFA]} { break }
} else {
set Encore 0
if {[file exists $FiMSF]} { continue }
set Encore 1
if {[file exists $FiBla]} { MSFPourCollection $Nom ; continue }
if {[file exists $FiProtTFA]} { BlastPPourCollection $Nom ; continue }
}
if {[file exists $FiProtEMBL] && ! [file exists $FiProtTFA]} {
set ProtTFA [SequenceFormatTFA [ContenuDuFichier $FiProtEMBL] "" "embl"]
Sauve $ProtTFA dans $FiProtTFA
continue
}
if {[file exists $FiVer]} {
set SeqVer [ContenuDuFichier $FiVer]
Espionne "SeqVer\n$SeqVer"
if { [OnTraiteDesCDS] || $NucOnly} {
set FormatVer [FormatDeLaSequence $SeqVer]
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 $FiNucEMBL
Sauve $NucTFA dans $FiNucTFA
set QueSeqNuc [QueLaSequenceDuTexteTFA $NucTFA]
set DernierCodon [string range $QueSeqNuc end-2 end]
if {[CodonStopPossible $DernierCodon]} { set QueSeqNuc [string range $QueSeqNuc 0 end-3] }
set SeqProt [SeqNucToSeqPro $QueSeqNuc]
set LongSeq [string length $SeqProt]
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $Nom created by Gscope from a CDS file "
set LigneAC [lindex [split $NucEMBL "\n"] 1]
if {[regexp "^AC " $LigneAC]} {
lappend LesLignesEMBL $LigneAC
} else {
lappend LesLignesEMBL "AC $Nom;"
}
set ChampsInteressants [ChampsInteressantsDansTexteEMBL $NucEMBL]
if {$ChampsInteressants!=""} {
foreach Champ [split $ChampsInteressants "\n"] {
lappend LesLignesEMBL $Champ
if {$GN=="" && [regexp "^GN " $Champ]} {
set GN [VraiGNDeLaLigneGN $Champ]
InformeSansDemander $Nom "ValiGN: $GN"
}
if {[regexp "^DE " $Champ]} {
set DE [VraiDEDeLaLigneDE $Champ]
InformeSansDemander $Nom "ValiDE: $DE"
}
}
}
if {$NucOnly} { continue }
lappend LesLignesEMBL "SQ SEQUENCE $LongSeq AA;"
lappend LesLignesEMBL [SequenceFormatBrut $SeqProt]
set ProtEMBL [join $LesLignesEMBL "\n"]
set ProtTFA [SequenceFormatTFA $ProtEMBL "$Nom" "embl"]
Sauve $ProtEMBL dans $FiProtEMBL
Sauve $ProtTFA dans $FiProtTFA
} else {
set SeqProt [SequenceFormatEMBL $SeqVer]
Espionne "SeqProt\n$SeqProt"
regsub {^ID [^\n]+} $SeqProt "ID $Nom created by Gscope" SeqProt
Sauve $SeqProt dans $FiProtEMBL
set Entete "$Nom"
set ChampsInteressants [ChampsInteressantsDansTexteEMBL $SeqProt]
if {$ChampsInteressants!=""} {
lappend LesLignesEMBL $ChampsInteressants
foreach Champ [split $ChampsInteressants "\n"] {
lappend LesLignesEMBL $Champ
if {[regexp "^GN " $Champ]} {
set GN [VraiGNDeLaLigneGN $Champ]
InformeSansDemander $Nom "ValiGN: $GN"
append Entete " $GN"
}
if {[regexp "^DE " $Champ]} {
set DE [VraiDEDeLaLigneDE $Champ]
InformeSansDemander $Nom "ValiDE: $DE"
append Entete " $DE"
}
}
}
set ProtTFA [SequenceFormatTFA $SeqProt "$Entete" "embl"]
Sauve $ProtTFA dans $FiProtTFA
}
continue
}
if {[OuiOuNon "The Query sequence for $Nom doesn't yet exists. \n\
Do I skipp $Nom [Alias $Nom] ?"]} {
break
}
}
FinPasTouche $Nom
}
}
set BanqueTBlastN ""
if {[OuiOuNon "Do I run a tblastn for all ? " 0]} {
set BanqueTBlastN [ChoixParmi [list "human" "genomes" "myself"]]
if {$BanqueTBlastN!=""} {
set RepTBlastN "$RepertoireDuGenome/tblastn$BanqueTBlastN"
if { ! [file exists $RepTBlastN]} { File mkdir $RepTBlastN }
TBlastNPourTous $BanqueTBlastN
}
}
if { ! [OuiOuNon "Do you want to complete the database ?" 0]} { return }
set BanqueTBlastN [WhichBanqueTBlastN $BanqueTBlastN]
CompleteLaDataBase $BanqueTBlastN
}
proc CreeLaBase {} {
global RepertoireDuGenome
global CurrentGenome
global FichierMiniConfig
global VersionDeGscopeAuBigBang
global FichierSequenceADN
global PrefixeDesORFs
global LongueurMiniDesORFs
global GenomeOuCollection
global Org1 Org2
if { ! [OuiOuNon "We will build, together, the database for $CurrentGenome.\
\n
\n ... this means beton/MiniConfig \
\n beton/adn tdn rac \
\n fiches/bornesdespabs \
\n nuctfa/*, prottfa/*, nucembl/*, protembl/* \
\n fiches/compositionenatgc\
\n blastp/*, apn/* fiches/nombredecopainsdansblast \
\n msf/*, phylo \
\n tblastngenomes/* TwoGeneClusterAnalysis etc. \
\n
\n If some of these files exist You can delete them before answering.\
\n \
\n Go ?"]} {
if {[OuiOuNon "Do I exit ?"]} { exit } else { return }
}
set GenomeOuCollection "Genome"
set LesRepertoiresNecessaires {"beton" "fiches" "infos"}
foreach Rep $LesRepertoiresNecessaires {
if {[file exists "$RepertoireDuGenome/$Rep"]} { continue }
File mkdir "$RepertoireDuGenome/$Rep"
}
while { ! [file exists $FichierMiniConfig]} {
set VersionDeGscopeAuBigBang "VersionDeGscopeAuBigBang [VersionDeGscope]"
set FichierSequenceADN ""
while {$FichierSequenceADN==""} {
set TFA [lindex [glob -nocomplain $RepertoireDuGenome/beton/*.tfa] 0]
if {$TFA == ""} { set TFA "$RepertoireDuGenome/" }
if {[OuiOuNon "Can You browse for DNA sequence file ?"]} {
set TFA [ButineArborescence "All" $TFA]
if {$TFA==""} { continue }
set FichierSequenceADN "FichierSequenceADN $TFA"
break
}
if {[OuiOuNon "Do You want to concatenate contigs ?"]} {
set RepertoireContigs "$RepertoireDuGenome/contigs"
while { ! [file exists $RepertoireContigs]} {
if { ! [OuiOuNon "Before answering, could You create $RepertoireContigs\n\
containing all the contigs files ?"]} { break }
}
if {[file exists $RepertoireContigs]} {
set TFA [ConcateneLesContigs]
if {$TFA==""} { continue }
set FichierSequenceADN "FichierSequenceADN $TFA"
break
}
}
if {[OuiOuNon "Do You want to read GenBank files ?"]} {
set OffsetNumero 0
while {[OuiOuNon "Do I use the ORF numbering in the GenBank files ?" 0]} {
if {[OuiOuNon "From the /locus-tag ?"]} {
set OffsetNumero "NumeroDansLocusTag"
break
}
if {[OuiOuNon "From the /gene and-or the /note field ?"]} {
set OffsetNumero "NumeroDansGeNo"
break
}
if {[OuiOuNon "Only from the /gene field ?"]} {
set OffsetNumero "NumeroDansGene"
break
}
if {[OuiOuNon "Only from the /note field ?"]} {
set OffsetNumero "NumeroDansNote"
break
}
}
if {$OffsetNumero!=0} {
global SupposePrefixe
if { ! [info exists SupposePrefixe]} {
set SupposePrefixe ""
while {$SupposePrefixe==""} {
if {[OuiOuNon "Do You know which prefixe is used for ORF numbering ?" 0]} {
set SupposePrefixe [Entre "ECU\[0-9\]+_"]
if {$SupposePrefixe!=""} { break }
} else {
break
}
}
}
}
while {1} {
FaireLire "I accept 3 situations ;\n \
One GenBank file \n \
Several GenBank files are in one directory, without other files\n \
or \n \
The file are somewhere (with other files) but numbered in increasing order"
if {[OuiOuNon "Is there only ONE GenBank file to read ?"]} {
set FichiersGB [ButineArborescence All $RepertoireDuGenome]
break
} elseif {[OuiOuNon "Are all the GenBank files alone in one directory ?"]} {
set Rep [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/"]
if {$Rep==""} { continue }
set FichiersGB "$Rep/*"
break
} elseif {[OuiOuNon "OK for increasing numbering.\nPlease browse for one of these files"]} {
set FichiersGB [ButineArborescence All $RepertoireDuGenome]
if {$FichiersGB==""} { continue }
if {[regexp {[0-9]+$} $FichiersGB]} {
regsub {[0-9]+$} $FichiersGB "" FichiersGB
}
break
} else {
continue
}
}
if {$FichiersGB!=""} {
set TFA [DecortiqueLesGenBank $FichiersGB $OffsetNumero]
if {$TFA==""} { continue }
set FichierSequenceADN "FichierSequenceADN $TFA"
break
}
}
if {[OuiOuNon "Do You want to read a FASTA file with all your sequences ?"]} {
CreeLesPABsAvecUnProteomeDansTFAs
break
}
if {[OuiOuNon "Do You want to use an existing ORF list ?\n(typically from an other Gscope project)"]} {
CreeLeFichierBornesDesPABs
break
}
if {[OuiOuNon "Do I stop ?"]} { exit }
}
set PrefixeDesORFs [Entre "PrefixeDesORFs ORF"]
regsub { *PrefixeDesORFs *} $PrefixeDesORFs "" P
set PrefixeDesORFs "PrefixeDesORFs $P"
set LongueurMiniDesORFs [Entre "LongueurMiniDesORFs 300"]
regsub { *LongueurMiniDesORFs *} $LongueurMiniDesORFs "" L
set LongueurMiniDesORFs "LongueurMiniDesORFs $L"
FaireLire "Please select the organism."
set Genre "Genius"
set Espece "species"
scan [MontreOrganismes "AvecRetour"] "%s %s %s" Orga Genre Espece
set TexteNotreOS "NotreOS $Genre $Espece."
set TexteNotreOC "NotreOC [OCduOS "$Genre $Espece"]"
set TexteNotreOX "NotreOX [NotreOX]"
set GenomeOuCollection "GenomeOuCollection Genome"
set LaConfig {}
lappend LaConfig "#MiniConfig "
lappend LaConfig "$FichierSequenceADN"
lappend LaConfig "$VersionDeGscopeAuBigBang"
lappend LaConfig "$PrefixeDesORFs"
lappend LaConfig "$LongueurMiniDesORFs"
lappend LaConfig "$TexteNotreOS"
lappend LaConfig "$TexteNotreOC"
lappend LaConfig "$TexteNotreOX"
lappend LaConfig "$GenomeOuCollection"
if {[OuiOuNon "[join $LaConfig "\n"]\n\n OK ?" ]} {
SauveLesLignes $LaConfig dans $FichierMiniConfig
} else {
if {[OuiOuNon "Stop ?"]} { exit }
}
}
ChargeMiniConfig
LesOrganismesTresProches
if { ! [file exists "$RepertoireDuGenome/beton/adn"]} {
set AncienNomDuFichierSequenceADN $FichierSequenceADN
if {[OuiOuNon "Should I create $RepertoireDuGenome/beton/adn tdn rac ?"]} {
CreeADNetTDNetRACaPartirDuFichierTFA $FichierSequenceADN
CreeCompletTFAavecADN
}
if {[file exists "$AncienNomDuFichierSequenceADN.pure"] && \
[OuiOuNon "Should I create $RepertoireDuGenome/beton/adn.pure tdn.pure rac.pure ?"]} {
CreeADNetTDNetRACaPartirDuFichierTFA "$AncienNomDuFichierSequenceADN.pure"
}
}
if { ! [file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} {
CreeLeFichierBornesDesPABs
}
if { [OuiOuNon "Do I run some basic sequence analysis ?"]} {
if { [OuiOuNon "Do I create the files Nuc and Prot ? "]} {
CreeLesFichiersNucTFAetProtTFAetNucEMBLetProtEMBLAvecBornesDesPABsEtADN
}
set SeqLaTotale [OuiOuNon " Do I run all standard analysis ?\n\
ATGC composition, GC drawing, ShineDalgarno\n\
CodonW, Glimmer, tRNAscan\n\
(I hope You didn't forget to setcodonW setglimmer settrnascan !)"]
if { $SeqLaTotale || [OuiOuNon "Do I create the file compositionenatgc ? "]} {
CreeLeFichierCompositionEnATGC
}
if { $SeqLaTotale || [OuiOuNon "Do I create the file spectregc ? "]} {
CreeLesFichiersSpectreDesGC
}
if { $SeqLaTotale || [OuiOuNon "Do I see for ShineDalgarno ? "]} {
CreeLesFichiersDesShineDalgarnoDesPABs
}
if { $SeqLaTotale || [OuiOuNon "Do I run CodonW for Codon Adaptation Index ? \n(Answer No if you didn't 'setcodonw'.)"]} {
CodonW
}
if { $SeqLaTotale || [CreateurDesPABs] != "Glimmer" && [OuiOuNon "Do I run Glimmer to compare with existing ORFs ?"]} {
Glimmer "GLIMMER0000"
CreeCorrespondanceAvecGlimmer
}
if { $SeqLaTotale || [OuiOuNon "Do I run tRNAscan-SE ? "]} {
TRNAscanSE
CreeLesFichiersNucTFAetNucEMBLAvecBornesDesTRNAsEtADN
}
}
if { [OuiOuNon "Do I run all BlastP ? "]} {
BlastPPourTous
}
if { [OuiOuNon "Do I run all BlastN against human ? "]} {
BlastNPourTous
}
set BanqueTBlastN ""
if {[OuiOuNon "Do I run a tblastn for all ? "]} {
set BanqueTBlastN [ChoixParmi [list "human" "genomes" "myself"]]
if {$BanqueTBlastN!=""} {
set RepTBlastN "$RepertoireDuGenome/tblastn$BanqueTBlastN"
if { ! [file exists $RepTBlastN]} { File mkdir $RepTBlastN }
TBlastNPourTous $BanqueTBlastN
}
}
set BanqueTBlastN [WhichBanqueTBlastN $BanqueTBlastN]
if { ! [OuiOuNon "Do You want to complete the database ?"]} { return }
CompleteLaDataBase $BanqueTBlastN
if {[OuiOuNon "Do I exit Gscope ?"]} { exit }
}
proc CompleteLaDataBase {{BanqueTBlastN ""}} {
global RepertoireDuGenome
global NotreOS
global NotreOC
global Org1 Org2
if { [file exists "$RepertoireDuGenome/blastp"] && [OuiOuNon "Can I count the blastp hits ? "]} {
if {[OuiOuNon "Do I use Daedalus ?"]} {
DaedalusHitsDuBlastPPourTous
CreeLeFichierNombreDeCopainsDansBlast
} else {
CreeLesFichiersApns
CreeLeFichierNombreDeCopainsDansBlast
}
WithPDB "CreateIt"
}
if { [file exists "$RepertoireDuGenome/blastn"] && [OuiOuNon "Can I count the blastn hits ? "]} {
CreeLesFichiersApns blastn
CreeLeFichierNombreDeCopainsDansBlast
}
if {[file exists "$RepertoireDuGenome/apns"] && [OuiOuNon "Do I create Narcisse (the database reference of each prot) ?" ]} {
Narcisse CreateIt
if {[OuiOuNon "Do I update /infos files with the fields ID AC DE GN found in the database ?"]} {
InformeParNarcissePourTous
}
}
if {[file exists "$RepertoireDuGenome/apns"] && [OuiOuNon "Do I create OrthoBlastP ?" ]} {
CreeOrthoBlastP
ORGAorgaDesBlastPs "CreateIt"
}
AnalyseLesDbClustal
if { [OuiOuNon "Do I create the phylo ranks ? "]} {
PhyloRank
}
AnalyseLesTBlastN $BanqueTBlastN
if {[OuiOuNon "Do I create the summary files in $RepertoireDuGenome/notes/ ?"]} {
CreeToutesLesNotes
}
}
proc AnalyseLesDbClustal {} {
if { [OuiOuNon "Do I run analysis on DBClustal outputs ? "]} {
set DisPhy [OuiOuNon "CreeDistancesPhyloAvecLesMSFs ?"]
set PIPS [OuiOuNon "CreeLesFichiersPIClustalwEtPSClustalw ?"]
set Oo [OuiOuNon "ORGAorgaDesMSFs ?"]
set PhylOr [OuiOuNon "PhylumsOrthologues ?"]
set Para [OuiOuNon "AlignonsLesParalogues ?"]
set TCSD [OuiOuNon "TestCodonStartEtDeletionDuMSFPourTous ?"]
set TCSC [OuiOuNon "StartCodonClusterPourTous and CreeStartCodonReport ?"]
set Diff [OuiOuNon "DifferentielBlastAlignementPourTous ?"]
if { $DisPhy } { CreeDistancesPhyloAvecLesMSFs }
if { $PIPS } { CreeLesFichiersPIClustalwEtPSClustalw}
if { $Oo } { ORGAorgaDesMSFs "CreateIt" }
if { $PhylOr } { PhylumsOrthologues bidon }
if { $Para } { AlignonsLesParalogues }
if { $TCSD } { TestCodonStartEtDeletionDuMSFPourTous }
if { $TCSC } { StartCodonClusterPourTous ; CreeStartCodonReport }
if { $Diff } { DifferentielBlastAlignementPourTous }
}
}
proc AnalyseLesTBlastN {{BanqueTBlastN ""}} {
global RepertoireDuGenome
set BanqueTBlastN [WhichBanqueTBlastN $BanqueTBlastN]
set LaTotale 0
if {[OuiOuNon "Do I run all analysis for tBlastN ?\n \
ouatapetbn, orthotblastn, ootblastn, two genes cluster, ... ?"]} {
set LaTotale 1
}
if {[file exists "$RepertoireDuGenome/tblastn$BanqueTBlastN"] && \
! [file exists "$RepertoireDuGenome/fiches/ouatapetbn.$BanqueTBlastN"]} {
if {$LaTotale || [OuiOuNon "Do I create fiches/ouatapetbn.$BanqueTBlastN ?"]} {
CreeOuATapeTBlastN $BanqueTBlastN
}
}
if {[file exists "$RepertoireDuGenome/fiches/ouatapetbn.$BanqueTBlastN"] && \
! [file exists "$RepertoireDuGenome/fiches/orthotblastn"]} {
if {$LaTotale || [OuiOuNon "Do I create orthotblastn ?"]} {
CreeOrthoTBlastN
}
}
if {[file exists "$RepertoireDuGenome/fiches/orthotblastn"] && \
! [file exists "$RepertoireDuGenome/fiches/ootblastn"]} {
if {$LaTotale || [OuiOuNon "Do I create ootblastn ?"]} {
ORGAorgaDesTBlastNs "CreateIt"
}
}
if {[file exists "$RepertoireDuGenome/fiches/ouatapetbn.$BanqueTBlastN"] && \
! [file exists "$RepertoireDuGenome/fiches/organismesayantmemeoperon"]} {
if {$LaTotale || [OuiOuNon "Do I run TwoGeneClusterAnalysis ?"]} {
CreeLeFichierOrganismesAyantMemeOperon genomes
}
}
if {[file exists "$RepertoireDuGenome/fiches/ouatapetbn.$BanqueTBlastN"] && \
[info exists Org1] && \
! [file exists "$RepertoireDuGenome/fiches/orthologuesdans$Org1"]} {
if {$LaTotale || [OuiOuNon "Do I check for orthologs in $Org1 and $Org2 ? "]} {
foreach Orga [LesOrganismesTresProches] {
CreeLeFichierOrthologueDans $Orga
}
}
}
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.