Index by: file name |
procedure name |
procedure call |
annotation
gscope_oi.tcl
(annotations | original source)
#rR gscope_oi.tcl
#rR 20170101 Traitement des proteomes des poissons de Audrey Defosset
#rR on reprend ici ce qui a été fait pour CilioCarta
#rR avec de nouveaux noms
#rR OiName devient ainsi OiCode
#rR Yannis a ramené les protéomes Achaea Bacteria Eukaryota et Virus
#rR Pour chaqcun j'ai créé desprotéomes bien nommé (dans NotaBene dans un premier temps)
#rR Et je leur ai donné un nouveau nom qui ICI SERA APPELE OI de OiCode
#rR C'est la procédure OiCode
#rR Pour la bactérie 'Trucmuch machin chose' ce sera BTruma et s'il y a plusieurs BTruma ce sera BTrumaA BTrumaB ... BTrumaZ BTrumaAA BTrumaAB ...
proc GyraseTfasDesCopains {} {
#rR On lit le taxobla et si l'access est celui d'un proteome cité dans les fichiers lus par Gyrase
#rR on va le chercher dans les proteomes de NotaBene
set TfaCopDir "[RepertoireDuGenome]/tfasdescopainsGyrase"
file mkdir $TfaCopDir
foreach Nom [ListeDesPABs] {
set FicTfaCop "$TfaCopDir/$Nom"
if {[file exists $FicTfaCop]} { continue }
set FicTaxobla [GscopeFile $Nom "taxobla"]
if {[FileAbsent $FicTaxobla]} { continue }
Espionne $Nom
set LesSeq {}
foreach Ligne [LesLignesDuFichier $FicTaxobla] {
scan $Ligne "%s %s %s" PN SCore Ox
if {[Gyrase $Ox YN]==""} { continue }
set FicTfaProteome [OiCode $Ox FullFilePath]
set Info [lindex [split $Ligne "\t"] 4]
scan $Info "%s %s" BId Ac
set Bank [StringApres "BANK=" dans $Info]
set Access "$Bank|$Ac|$BId"
set Seq [LaSequenceDuTFAs $FicTfaProteome $Access]
if {$Seq==""} { continue }
lappend LesSeq $Seq
}
SauveLesLignes $LesSeq dans $FicTfaCop
lappend LesCrees $FicTfaCop
}
return $LesCrees
}
proc Gyrase {{Qui ""} {Quoi ""}} {
global Gyrase
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists Gyrase($Qui,$Quoi)]} { return $Gyrase($Qui,$Quoi) }
if {[info exists Gyrase("EstCharge")]} { return "" }
set Gyrase("EstCharge") 1
set Gyrase(YES,FILENAME) "/genomics/link/AArcfu/DeClaudine/14"
set Gyrase(NO,FILENAME) "/genomics/link/AArcfu/DeClaudine/16"
foreach YN [list NO YES] {
foreach Ligne [LesLignesDuFichier $Gyrase($YN,FILENAME)] {
set Os [string trim $Ligne]
set Oi [OiCode $Os OI]
set Ox [OiCode $Os OX]
lappend Gyrase($YN,LISTOFOI) $Oi
lappend Gyrase($YN,LISTOFOS) $Os
lappend Gyrase($YN,LISTOFOX) $Ox
lappend Gyrase(ALL,LISTOFOI) $Oi
lappend Gyrase(ALL,LISTOFOS) $Os
lappend Gyrase(ALL,LISTOFOX) $Ox
set OX $Ox
set OI [string toupper $Oi]
set OS [string toupper $Os]
set Gyrase($OI,OI) $Oi
set Gyrase($OI,OS) $Os
set Gyrase($OI,OX) $Ox
set Gyrase($OI,YN) $YN
set Gyrase($OS,OI) $Oi
set Gyrase($OS,OS) $Os
set Gyrase($OS,OX) $Ox
set Gyrase($OS,YN) $YN
set Gyrase($OX,OI) $Oi
set Gyrase($OX,OS) $Os
set Gyrase($OX,OX) $Ox
set Gyrase($OX,YN) $YN
}
}
return [Gyrase $Qui $Quoi]
}
proc OiLikeFishProteomes {{Rep ""}} {
##rR on remplace
#>XP_018528244.1 PREDICTED: F-box only protein 15-like isoform X1 [Lates calcarifer]
#par
#>XP_018528244.1 PREDICTED: F-box only protein 15-like isoform X1 OS=Lates calcarifer OX=123456
if {$Rep==""} { set Rep "/home/defosset/These/Proteome/Purged_proteomes/Other_fish" }
NousAllonsAuBoulot "$Rep/NotaBene"
set LesNotaBene {}
foreach Fic [glob "../*_purged"] {
Espionne $Fic
if { ! [regexp -nocase {^../([a-z]+)_([a-z]+)_purged$} $Fic Match Genre Espece]} { FaireLire "$Fic bad name" ; continue }
set OS "${Genre} ${Espece}"
set OX [Tax $OS]
if {$OX==""} { FaireLire "$OS has no TaxId" }
set LeNew {}
foreach Access [LaSequenceDuTFAs $Fic "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $Fic $Access]
set Entete [EnteteDuTexteTFA $TFA]
set Seq [QueLaSequenceDuTexteTFA $TFA]
regsub {\[.+$} $Entete "" Entete
append Entete " OS=$OS OX=$OX"
set New [SequenceFormatTFA $Seq $Entete "protbrut"]
lappend LeNew $New
}
set FishCode "F[string range $Genre 0 2][string range $Espece 0 1]"
if {[info exists DejaVu($FishCode)]} { set FishCode [Entre "$FishCode deja vu"] }
set NewName ${FishCode}_[join [split $OS " "] "_"]_$OX
lappend LesNotaBene $NewName
Espionne $NewName
SauveLesLignes $LeNew dans $NewName
}
OnRevientDuBoulot
return $LesNotaBene
}
proc BiggestHeaderPourTous {{Rep ""}} {
if {$Rep==""} { set Rep "." }
foreach Fasta [lsort [glob -nocomplain "$Rep/*"]] {
set R [BiggestHeader $Fasta]
scan $R "%d" M
if {$M>600} { Espionne "$Fasta\n$R" }
}
}
proc BiggestHeader {Fichier} {
set Max 0
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase "^>" $Ligne]} { continue }
set L [string length $Ligne]
if {$L>$Max} {
set Max $L
set Biggest $Ligne
}
}
return "$Max $Biggest"
}
proc OiProteomesDir {} {
return "/genomics/link/OrthoInspector_Proteomes/Proteomes2016"
}
proc OiDomainFromOiCode {OiCode} {
return [OiDomain [string index $OiCode 0] Que]
}
proc OiDomain {{Value ""} {Quoi ""}} {
global OiDomain
global OIDomainStack
#rR Positionne Rend le domaine ou la dir du domaine concerné Euka Bact Arch Virus Qfo
#rR Une lettre suffit pour les domaines pour les mots clés il en faut au moins 3
#rR ... mais attention il ne faut pas que les domaines commencent pas les mots clefs listés ci-dessous
#rR OiDomain rend le defaut (Eukaryota) ou autre s'il a été modifié précédemment
#rR OiDomain B positionne à Bacteria et rend Bacteria
#rR OiDomain B Dir positionne à Bacteria et rend /genomics/link/OrthoInspector_Proteomes/Bacteria
#rR OiDomain Dir rend /genomics/link/OrthoInspector_Proteomes/Bacteria si c'est le dernier positionné
#rR OiDomain Dir B pareil que l'inverse
#rR OiDomain Lis rend la liste de ce qui existe
#rR On peut mémoriser par OiDomain MemorizeThenSetTo Nouveau
#rR .... et dépiler par OiDomain BackToMemorized
set ProteomesDir [OiProteomesDir]
set LesInitiales {}
set LesQueues {}
foreach PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/*"] {
set Queue [file tail $PossibleDir]
if {[regexp "NewSoft" $Queue]} { continue } ;#rR 20220207
if {$Queue=="QFO"} { continue } ;#rR a supprimer !!!!!!!!!!!!!!!!!!
lappend LesQueues $Queue
set Ini [string index $Queue 0]
lappend LesInitiales $Ini
set QueueDe($Ini) $Queue
}
if {$Value=="Ini"} { return $LesInitiales }
if {$Quoi=="Que"} {
if {[info exists QueueDe($Value)]} {
return $QueueDe($Value)
} else {
return ""
}
}
if {$Value=="Ask"} {
set PossibleDirs [lsort [glob -nocomplain -type "d" "$ProteomesDir/*"]]
foreach PossibleDir $PossibleDirs {
if {[regexpo "NewSoft" $PossibleDir]} { continue } ; #rR 20220207
lappend LesQueue [file tail $PossibleDir]
}
set Choix [ChoixParmi $LesQueue]
if {$Choix==""} { return "" }
return [OiDomain $Choix $Quoi]
}
if { ! [info exists OiDomain]} {
if {[OnTraite ArchaeaProteome Like]} {
set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/Archaea"] ; #rR pour enlever NewSoft
} elseif {[OnTraite BacteriaProteome Like]} {
set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/B*"]
} elseif {[OnTraite EukaryotaProteome Like]} {
set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/E*"]
} elseif {[OnTraite TransverseProteome Like]} {
set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/T*"]
} elseif {[OnTraite QfoProteome Like]} {
set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/Q*"]
} else {
set PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/Eukaryota"] ; #rR pour enlever NewSoft
}
set OiDomain [file tail $PossibleDir]
set OIDomainStack [list $OiDomain]
}
if {[regexp -nocase "^Memo" $Value]} {
lappend OiDomainStack $OiDomain
set OiDomain $Quoi
return $OiDomain
}
if {[regexp -nocase "BackTo" $Value]} {
set OiDomain [lindex $OIDomainStack 0]
set OIDomainStack [lrange $OIDomainStack 0 end-1]
return $OiDomain
}
set VAL [string totitle [string range $Value 0 2]]
set Quoi [string totitle [string range $Quoi 0 2]]
if {$VAL in [list Dir Lis Que]} {
set W $VAL
set VAL $Quoi
set Quoi $W
}
set V [string toupper [string index $VAL 0]]
if {$V!=""} {
set Dir ""
set Dom ""
foreach PossibleDir [glob -nocomplain -type "d" "$ProteomesDir/*"] {
Espionne $PossibleDir
set Queue [file tail $PossibleDir]
if {[regexp "NewSoft" $Queue]} { continue } ; #rR 20220207
if {$Queue=="QFO"} { continue }
if {$V==[string toupper [string index $Queue 0]]} {
set Dir $PossibleDir
set OiDomain $Queue
break
}
}
}
if {$Quoi=="Que"} { return [lsort $LesQueues] }
if {$Quoi=="Lis"} { return [lsort [glob -nocomplain -type "d" "$ProteomesDir/*"]] }
if {$Quoi=="Dir"} { return "$ProteomesDir/$OiDomain" }
return $OiDomain
}
proc OiCodeForDomain {Dom args} {
set GoBack 0
if {[OiDomain]!=$Dom} {
OiDomain "MemorizeThenSetTo" $Dom
OiCode "Reset"
set GoBack 1
}
set R [OiCode {*}$args]
if {$GoBack} {
OiDomain "BackToMemorized"
}
return $R
}
proc OiCreateOrganismXml {{Domaine ""} {DefBkDate ""} {DefBkIdentifier ""} {DefBkDescription ""}} {
if {$Domaine==""} { set Domaine [OiDomain] }
if {$DefBkDate ==""} { set DefBkDate "2016-11-17" }
if {$DefBkIdentifier ==""} { set DefBkIdentifier "UniprotKB" }
if {$DefBkDescription ==""} { set DefBkDescription "$DefBkIdentifier - $DefBkDate" }
OiDomain "MemorizeThenSetTo" $Domaine
set Fichier "[OiCode ProteomesDir]/OtherDB.txt"
if {[FileExists $Fichier]} {
foreach Ligne [LesLignesDuFichier $Fichier] {
set Date ""
set Iden ""
set Desc ""
lassign [split $Ligne "\t"] OX Date Iden Desc
set OtherDB($OX,BkDate) $Date
set OtherDB($OX,BkIdentifier) $Iden
set OtherDB($OX,BkDescription) $Desc
}
}
set LesOX [OiCode ListOf OX]
set File "[OiCode NotaBeneDir]/organism.xml"
set LeXml {}
lappend LeXml "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
lappend LeXml "<orthoinspector>"
foreach OX $LesOX {
set BkDate $DefBkDate
set BkIdentifier $DefBkIdentifier
set BkDescription $DefBkDescription
if {[info exists OtherDB($OX,BkDate) ]} { set BkDate $OtherDB($OX,BkDate) }
if {[info exists OtherDB($OX,BkIdentifier) ]} { set BkIdentifier $OtherDB($OX,BkIdentifier) }
if {[info exists OtherDB($OX,BkDescription)]} { set BkDescription $OtherDB($OX,BkDescription) }
if {$BkDescription ==""} { set BkDescription "$BkIdentifier - $BkDate" }
set OS [OiCode $OX OS]
set OI [OiCode $OX OI]
set FullFilename [OiCode $OX FullFilename]
set Class [TaxClass $OX "TaxId"]
Espionne "$OX $OS $OI $FullFilename"
scan $OS "%s %s" Genre Espece ; #rR c'était avant 2017/02/02
regsub "$Genre " $OS "" Espece ; #rR on garde tout
lappend LeXml " <organism>"
lappend LeXml " <genus>$Genre</genus>"
lappend LeXml " <species>$Espece</species>"
lappend LeXml " <identifier>$OI</identifier>"
lappend LeXml " <phylum>$Class</phylum>"
lappend LeXml " <source>"
lappend LeXml " <bank>"
lappend LeXml " <bk_date>$BkDate</bk_date>"
lappend LeXml " <bk_identifier>$BkIdentifier</bk_identifier>"
lappend LeXml " <bk_description>$BkDescription</bk_description>"
lappend LeXml " <bk_taxinomy>"
lappend LeXml " <taxid>$OX</taxid>"
lappend LeXml " </bk_taxinomy>"
lappend LeXml " </bank>"
lappend LeXml " </source>"
lappend LeXml " <fastafile>$FullFilename</fastafile>"
lappend LeXml " </organism>"
}
lappend LeXml "</orthoinspector>"
set Xml [join $LeXml "\n"]
OiDomain "BackToMemorized"
set Retour [Sauve $Xml dans $File]
return $Retour
}
proc CreeBlastDatabaseWithOiCode {Domaine {NomBanque ""} {FormatdbOrMakeblastdb ""}} {
if {$FormatdbOrMakeblastdb==""} { set FormatdbOrMakeblastdb "makeblastdb" }
set LesFasta [OiCodeForDomain $Domaine ListOf FullFilePath]
if {$NomBanque==""} { set NomBanque "Oi$Domaine" }
set Rep "/blast/OrthoInspector"
file mkdir $Rep
NousAllonsAuBoulot $Rep
if {[file exists $NomBanque] || [file exists $NomBanque.phr]} {
if { ! [OuiOuNon "$NomBanque already exist. Do I overwrite"]} { OnRevientDuBoulot; return "" }
}
set F [open $NomBanque "w"]
foreach Fasta $LesFasta {
set TFA [ContenuDuFichier $Fasta]
puts $F $TFA
}
close $F
if {$FormatdbOrMakeblastdb=="formatdb"} {
exec formatdb -i $NomBanque -p T -l $NomBanque.formatdb.log -o
} else {
exec /biolo/blast/bin/makeblastdb -dbtype prot -in $NomBanque -out $NomBanque -hash_index -parse_seqids
}
OnRevientDuBoulot
return "$Rep/$NomBanque"
}
proc OrderedClades {Clades {GetWhat ""}} {
#rR on trie les Cladespour avoir les plus grosses situées après les plus petites contenues dans les grosses.
if {[regexp "," $Clades]} { set Clades [split $Clades ","] }
set LesEmpty {}
set LesOX {}
foreach Clade $Clades {
set OX [Tax $Clade TaxId]
if {$OX==""} { lappend LesEmpty $Clade ; continue }
set CladeOf($OX) $Clade
lappend LesOX $OX
}
#rR ne sert plus ...il suffit de trier bêtement les classes
#set LesOrderedOX [lsort -command CompareCladeAncestor $LesOX]
foreach OX $LesOX {
set Class [TaxClass $OX]
lappend LesOrderedClass $Class
set OXDeLaClass($Class) $OX
}
set LesOrderedClass [lsort -decreasing $LesOrderedClass]
set LesOrderedOX {}
foreach Class $LesOrderedClass {
lappend LesOrderedOX $OXDeLaClass($Class)
}
set LesOrdered {}
foreach OX $LesOrderedOX {
lappend LesOrdered $CladeOf($OX)
}
foreach Empty $LesEmpty {
lappend LesOrdered $Empty
}
if {$GetWhat=="JoinedList"} { return [join $LesOrdered ","] }
return $LesOrdered
}
proc TestArClade {} {
foreach Ligne [LesLignesDuFichier [GscopeFile AHalma04100 taxobla]] {
scan $Ligne "%s %s %s" E S OX
Espionne [format "%-30s %s OX = %s" [ArCladeOf $OX Name] [Tax $OX Name] $OX]
}
}
proc TestArchaeaGenomesDeClaudine {} {
foreach OS [ClaudineArchaea ListOf OS] {
regsub -all " +" [string trim $OS] "_" OS
Espionne [format "%-30s %s" [ArCladeOf $OS Name] $OS]
}
}
proc ArCladeOf {{Qui ""} {Quoi ""}} {
global ArCladeOf
if {$Quoi=="Clade"} { set Quoi "Name" }
if {[regexp -nocase "taxid" $Quoi]} { set Quoi "OX" }
if {$Quoi=="" && [regexp {^[0-9]+$} $Qui]} { set Quoi "OX" }
if {$Quoi=="" && ! [regexp {^[0-9]+$} $Qui]} { set Quoi "Name" }
if {[info exists ArCladeOf($Qui,Quoi)]} { return $ArCladeOf($Qui,$Quoi) }
set OX [Tax $Qui TaxId]
set OS [Tax $Qui Name]
foreach CX [ArClade ListOf OrderedOX] CS [ArClade ListOf OrderedName] {
if {[JeSuisTonAncetre $CX $OX]} {
set ArCladeOf($OX,OX) $CX
set ArCladeOf($OS,OX) $CX
set ArCladeOf($OX,Name) $CS
set ArCladeOf($OS,Name) $CS
if {[info exists ArCladeOf($OX,$Quoi)]} { return $ArCladeOf($OX,$Quoi) }
}
}
return ""
}
proc CompareCladeAncestor {A B} {
#rR je crois que ça ne sert plus .. il suffit de trier les classes.
#rR attention il y a aussi CompareArCladeAncestor où on a déjà mémorisé
if {$A==$B} { return 0 }
if {[JeSuisTonAncetre $B $A]} { return -1 }
if {[JeSuisTonAncetre $A $B]} { return 1 }
return 0
}
proc CompareArCladeAncestor {A B} {
#rR attention il y a aussi CompareCladeAncestor où on utilise directement JeSuisTonAncetre
global ArClade
ArClade
if {$A==$B} { return 0 }
if {[info exists ArClade($B,AncestorOf_$A)]} { return -1 }
if {[info exists ArClade($A,AncestorOf_$B)]} { return 1 }
return 0
}
proc ArCladeOLD {{Qui ""} {Quoi ""}} {
global ArClade
if {[info exists ArClade($Qui,$Quoi)]} { return $ArClade($Qui,$Quoi) }
if {[info exists ArClade("EstCharge")]} {
if {[info exists ArClade($Qui,OX)]} {
set OX $ArClade($Qui,OX)
if {[info exists ArClade($OX,$Quoi)]} { return $ArClade($OX,$Quoi) }
}
return ""
}
set ArClade("EstCharge") 1
set Fichier "/home/ripp/vrac/ArClade.txt"
set ArClade(Filename,) $Fichier
foreach Ligne [LesLignesDuFichier $Fichier] {
set Name [string trim $Ligne " \t"]
if {$Name==""} { continue }
regsub -all " " $Name "_" Name
set OX [Tax $Name TaxId]
if {$OX==""} {
#FaireLire "$Name has no TaxId. I'll use Archaea instead"
set Name "Archaea"
set OX [Tax $Name TaxId]
}
set ArClade($Name,Name) $Name
set ArClade($OX,OX) $OX
set ArClade($Name,OX) $OX
set ArClade($OX,Name) $Name
lappend ArClade(ListOf,OX) $OX
lappend ArClade(ListOf,Name) $Name
}
set ArClade(ListOf,OX) [lsort -unique $ArClade(ListOf,OX)]
set ArClade(ListOf,Name) [lsort -unique $ArClade(ListOf,Name)]
foreach A $ArClade(ListOf,OX) {
foreach B $ArClade(ListOf,OX) {
if {$A==$B} { continue }
if {[JeSuisTonAncetre $A $B]} { set ArClade($A,AncestorOf_$B) 1 }
}
}
set ArClade(ListOf,OrderedOX) [lsort -command CompareArCladeAncestor $ArClade(ListOf,OX)]
foreach OX $ArClade(ListOf,OrderedOX) {
lappend ArClade(ListOf,OrderedName) $ArClade($OX,Name)
}
#parray ArClade
foreach D [list Bacteria Eukaryota Virus] {
set N [Tax $D Name]
if {$N=="root"} { set N "Other" }
lappend ArClade(ListOf,OrderedOX) $D
lappend ArClade(ListOf,OrderedName) $N
}
return [ArClade $Qui $Quoi]
}
proc ArClade {{Qui ""} {Quoi ""}} {
global ArClade
if {[info exists ArClade($Qui,$Quoi)]} { return $ArClade($Qui,$Quoi) }
if {[info exists ArClade("EstCharge")]} {
if {[info exists ArClade($Qui,OX)]} {
set OX $ArClade($Qui,OX)
if {[info exists ArClade($OX,$Quoi)]} { return $ArClade($OX,$Quoi) }
}
return ""
}
set ArClade("EstCharge") 1
set LesClades [LesLignesDuFichier "/genomics/link/OI/fiches/PhylAr_ListOf_PhyOS.txt"]
set LesClades [OrderedClades $LesClades]
foreach Name $LesClades {
set OX [Tax $Name TaxId]
if {$OX==""} {
#FaireLire "$Name has no TaxId. I'll use Archaea instead"
set Name "Archaea"
set OX [Tax $Name TaxId]
}
set ArClade($Name,Name) $Name
set ArClade($OX,OX) $OX
set ArClade($Name,OX) $OX
set ArClade($OX,Name) $Name
lappend ArClade(ListOf,OX) $OX
lappend ArClade(ListOf,Name) $Name
}
set ArClade(ListOf,AllOX) $ArClade(ListOf,OX)
set ArClade(ListOf,AllName) $ArClade(ListOf,Name)
foreach Name [list Bacteria Eukaryota Viruses] {
set OX [Tax $Name TaxId]
if {$Name=="root"} { set Name "Other" }
lappend ArClade(ListOf,AllOX) $OX
lappend ArClade(ListOf,AllName) $Name
}
return [ArClade $Qui $Quoi]
}
proc ArchaeaGenomesDeClaudine {{GetWhat ""}} {
OiDomain A
foreach OS [OiCode ListOf OS] {
scan $OS "%s %s" Ge Es
set GeEs "$Ge$Es"
set OX [OiCode $OS OX]
#Espionne "$OX $GeEs \t\t$OS"
lappend LesOXde($GeEs) $OX
}
set LesGS {}
set Rates 0
set LesMemes {}
set LesCommeSoeur {}
set LesRates {}
set LesClaudine {}
set NbAvecSoeur 0
foreach G [ClaudineArchaea ListOf G] {
set GX [ClaudineArchaea $G OX]
set GS [ClaudineArchaea $G "Organism_Name"]
set OS [OiCode $GX OS]
set Clade [ArCladeOf $GX Name]
lappend LesClaudine [format "%s %9d %-50s %s %s %s" $G $GX $GS Clade = $Clade]
if {$OS!=""} {
set Meme($GX) 1
lappend LesMemes [format "%-9s %9d %-50s %-80s %s" $G $GX $GS $OS Clade = $Clade]
continue
}
set LesParents [list $GX]
set PX $GX
while {$OS==""} {
set PX [Tax $PX Parent]
if {$PX=="" || $PX==1} { break }
lappend LesParents $PX
set OS [OiCode $PX OS]
if {$OS!=""} { Espionne "$LesParents $OS" }
}
set LesSoeurs {}
set PX [Tax $GX Parent]
if {$PX!="" && $PX!=1} {
foreach OXSoeur [Tax $PX Children] {
set OS [OiCode $OXSoeur OS]
if {$OS!=""} {
lappend LesSoeurs "$OS OX = $OXSoeur"
set YaSoeur($OXSoeur) 1
}
}
if {$LesSoeurs!={}} {
incr NbAvecSoeur
lappend LesCommeSoeur ""
lappend LesCommeSoeur "$G $GX $Clade"
lappend LesCommeSoeur $GS
foreach Soeur $LesSoeurs {
lappend LesCommeSoeur $Soeur
}
}
if {$LesSoeurs!={}} { continue }
}
lappend LesRates [format "%9s %9d %-40s %s %s %s" $G $GX $GS Clade = $Clade]
}
foreach OX [OiCode ListOf OX] {
if {[info exists Meme($OX)]} {
lappend LesMemeQueYannis $OX
continue
}
lappend LesNouveauxDeYannis "$OX [OiCode $OX OS]"
}
set LesNouveauxDeYannis [lsort -index 1 $LesNouveauxDeYannis]
# return [AfficheListe $LesClaudine "" "Ceux de Claudine"]
Espionne "[llength $LesClaudine] de Claudine"
Espionne "[llength $LesMemes] Memes"
Espionne "$NbAvecSoeur AvecSoeur"
Espionne "[llength $LesRates] Rates"
Espionne "[llength [OiCode ListOf OX]] de Yannis"
Espionne "[llength $LesNouveauxDeYannis] Nouveaux chez Yannis"
set LesFenetres {}
lappend LesFenetres [AfficheListe $LesClaudine "" "Ceux de Claudine"]
lappend LesFenetres [AfficheListe $LesMemes "" "LesMemes"]
# lappend LesFenetres [AfficheListe $LesCommeSoeur "" "LesSoeurs"]
lappend LesFenetres [AfficheListe $LesRates "" "LesRates"]
lappend LesFenetres [AfficheListe $LesNouveauxDeYannis "" "LesNouveauxDeYannis"]
lappend LesFenetres [AfficheListe [OiCode ListOf Info] "" "Ceux de Yannis"]
return $LesFenetres
}
proc ClaudineArchaea {{Qui ""} {Quoi ""}} {
global CA
if {[info exists CA($Qui,$Quoi)]} { return $CA($Qui,$Quoi) }
if {[info exists CA("EstCharge")]} { return "" }
set CA("EstCharge") 1
set Fichier "/home/ripp/vrac/ClaudineArchaea.csv"
LoadTxl $Fichier CA 0 ";" "" "WholeLine"
set LesG {}
set LesOX {}
set LesOS {}
foreach I $CA(ListOf,Index) {
if { ! [regexp "^Go" $I]} { continue }
lappend LesG $I
set OX [GoldArchaea $I OX]
set CA($I,OX) $OX
if {$OX!=""} {
lappend LesOX $OX
lappend LesOS [Tax $OX Name]
}
}
set CA(ListOf,G) $LesG
set CA(ListOf,OX) $LesOX
set CA(ListOf,OS) $LesOS
return [ClaudineArchaea $Qui $Quoi]
}
proc GoldArchaea {{Qui ""} {Quoi ""}} {
global GoldArchaea
if {[info exists GoldArchaea($Qui,$Quoi)]} { return $GoldArchaea($Qui,$Quoi) }
if {[info exists GoldArchaea($Qui,Go)]} {
set Go $GoldArchaea($Qui,Go)
if {[info exists GoldArchaea($Go,$Quoi)]} { return $GoldArchaea($Go,$Quoi) }
}
if {[info exists GoldArchaea("EstCharge")]} { return "" }
set GoldArchaea("EstCharge") 1
set Fichier "/home/ripp/gscope/archaeaTax.txt"
foreach Ligne [LesLignesDuFichier $Fichier] {
lassign [split $Ligne "\t"] Go OS Dom OX Date
set Go [string trim $Go]
set OS [string trim $OS]
set OX [string trim $OX]
set Dom [string trim $Dom]
set Date [string trim $Date]
set GoldArchaea($Go,Go) $Go
set GoldArchaea($Go,OS) $OS
set GoldArchaea($Go,OX) $OX
set GoldArchaea($Go,Dom) $Dom
set GoldArchaea($Go,Date) $Date
lappend GoldArchaea(ListOf,Go) $Go
lappend GoldArchaea(ListOf,OS) $OS
lappend GoldArchaea(ListOf,OX) $OX
set GoldArchaea($OS,Go) $Go
set GoldArchaea($OX,Go) $Go
}
return [GoldArchaea $Qui $Quoi]
}
proc OiCodeDoublons {} {
set LesE [OiCodeForDomain E ListOf OI]
set LesA [OiCodeForDomain A ListOf OI]
set LesAE [ListsIntersection $LesA $LesE]
Espionne "[llength $LesA] [llength $LesE] [llength $LesAE]"
EspionneL $LesAE
}
proc GeEsFrom {OS} {
#rR Normalement on prend Hom sa
#rR Mais traitement spécial pour les bactéries qui commencent pas Bac (comme Bacteri Bacill ...)
if {[string index [OiDomain] 0]=="B" && [string range [string totitle $OS] 0 2]=="Bac"} {
set Ge "B"
set FinOS [string range $OS [string first " " $OS] end]
regsub -all " " $FinOS "" FinOS
regsub -all -nocase {[^a-z0-9]} $FinOS "" FinOS
regsub -all {[0-9]} $FinOS "d" FinOS
append FinOS "xxxxxx"
set Es [string range $FinOS 0 3]
} else {
scan $OS "%s %s" Ge Es
set Ge [string range $Ge 0 2]
set Es [string range $Es 0 1]
}
set GeEs [string totitle "$Ge$Es"]
regsub -all {[0-9]} $GeEs "d" GeEs
return $GeEs
}
proc OiCodes {LesQui {Quoi ""} {LesDomaines ""}} {
global OiCodes
if {[regexp {[ \t\,\;\n\r]+} $LesQui]} { set LesQui [LesMotsDuTexte $LesQui]}
#rR il se peut qu'on ait dèjaà tout mémorisé
set ToutDejaVu 1
set LaReponse {}
foreach Qui $LesQui {
if { ! [info exists OiCodes($Qui,$Quoi)]} { set ToutDejaVu 0 ; break }
lappend LaReponse "$Qui=$OiCodes($Qui,$Quoi)"
}
if {$ToutDejaVu} { return [join $LaReponse "\n"] }
if {$LesDomaines==""} {
#rR 20220207 set LesDomaines [list Archaea Bacteria Eukaryota Transverse]
set LesDomaines [list Archaea Bacteria Eukaryota]
} else {
set LesDomaines [LesMotsDuTexte $LesDomaines]
}
foreach Domaine $LesDomaines {
#OiDomain "MemorizeThenSetTo" $Domaine
set ToutTrouve 1
set DomaineCourant $Domaine
foreach Qui $LesQui {
Espionne "$Domaine $Qui OiCode $Qui $Quoi"
if {[info exists QuoiDe($Qui)] && $QuoiDe($Qui)!=""} { continue }
Espionne " $Domaine $Qui $Quoi"
set Q [OiCodeForDomain $Domaine $Qui $Quoi]
if {$Q!=""} {
set QuoiDe($Qui) $Q
} else {
foreach DomainePossible $LesDomaines {
#rR on essaie d'abord les autres domaines et on y reste si on trouve
if {$DomainePossible==$DomaineCourant} { continue }
Espionne "************* $DomainePossible $Qui $Quoi"
set QQ [OiCodeForDomain $DomainePossible $Qui $Quoi]
if {$QQ!=""} {
set Domaine $DomainePossible
set QuoiDe($Qui) $QQ
continue
}
}
set ToutTrouve 0
}
#Espionne "$Qui =$QuoiDe($Qui)="
}
if {$ToutTrouve} { break }
#OiDomain "BackToMemorized"
}
set LesQuiQuoi {}
foreach Qui $LesQui {
set R ""
if {[info exists QuoiDe($Qui)]} { set R $QuoiDe($Qui) }
lappend LesQuiQuoi "$Qui=$R"
set OiCodes($Qui,$Quoi) $R
}
set QuiQuoi [join $LesQuiQuoi "\n"]
return $QuiQuoi
}
proc OiCode {{Qui ""} {Quoi ""}} {
global OiCode
JeMeSignale
#rR OX est le TaxId, OS le vrai nom de l'organisme, OI le petit nom, OW l'organisme bien écrit
#rR On définit ici comment doit s'appeler un organisme son OiCode par exemple EHomsa pour Homo sapiens
#rR On nomme les fichiers OI_OW_OX et on rajoute pour chaque entête OI=EHomsa OX=9606
#rR Ces fichiers sont rangés dans le sous-répertoire NotaBene (les bien nommés ! ;) )
#rR OW est en fait le OS en remplaçant les caractères louches par _
#rR Attention Si on veut remplacer NotaBene par autre chose il faut le faire partout ...
#rR OiCode tient compte de OiDomain : Archaea Bacteria Eukaryota etc.
if {[regexp -nocase "PreFixe" $Quoi]} { set Quoi "OI" }
if {$Qui=="Reset"} {
if {[info exists OiCode]} { unset OiCode }
return ""
}
if {[info exists OiCode($Qui,$Quoi)]} { return $OiCode($Qui,$Quoi) }
if {[info exists OiCode("EstCharge")]} {
if {[info exists OiCode($Qui,OX)]} {
set OX $OiCode($Qui,OX)
if {[info exists OiCode($OX,$Quoi)]} { return $OiCode($OX,$Quoi) }
}
if {$Qui=="ListOf" && $Quoi=="OXOS"} {
set LesOXOS {}
foreach OX $OiCode(ListOf,OX) {
lappend LesOXOS "$OX $OiCode($OX,OS)"
}
return $LesOXOS
}
return ""
}
set OiCode("EstCharge") 1
set OiFromFullFilename 0 ; #rR 0 on va le chercher dans la première ligne. 1 c'est le premier Homsa_
set OsFromFullFilename 0 ; #rR 0 on va le chercher dans la première ligne. 1 c'est le premier entre les deux autres
set OxFromFullFilename 0 ; #rR 0 on va le chercher dans la première ligne. 1 c'est le dernier _9606
set ProteomesDir [OiDomain Dir]
set NotaBeneDir "$ProteomesDir/NotaBene"
set OiCode(ProteomesDir,) $ProteomesDir
set OiCode(NotaBeneDir,) $NotaBeneDir
# set Alphabet " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
set Alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
NousAllonsAuBoulot $ProteomesDir
Espionne $ProteomesDir
file mkdir NotaBene
set FichierBlackList "BlackList.txt"
if {[file exists $FichierBlackList]} {
foreach Ligne [LesLignesDuFichier $FichierBlackList] {
if {[regexp "#" $Ligne]} { continue }
scan $Ligne "%d" OX
lappend OiCode(ListOf,BlackListed) $OX
set OiCode($OX,IsBlackListed) 1
}
set OiCode(ListOf,BlackListed) [lsort -unique -integer $OiCode(ListOf,BlackListed)]
}
set OiCode(ListOf,Filename) {}
#rR attention il y a deux manières de procéder ...
#rR juste ci dessous on a déjà traité une partie et créé les fichiers OI_OW_OX
foreach Fichier [lsort [glob -nocomplain "NotaBene/*"]] {
set Queue [file tail $Fichier]
set OI "" ; if {$OiFromFullFilename && ! [regexp -nocase {^([a-z]+)_} $Queue Match OI ]} { continue }
set OW "" ; if { ! [regexp -nocase {^([a-z]+)_(.+)_([0-9]+)$} $Queue Match debut OW]} { continue } ; #rR On le prend toujours là
set OX "" ; if {$OxFromFullFilename && ! [regexp -nocase {_([0-9]+)$} $Queue Match OX ]} { continue }
set OS "" ; if {$OsFromFullFilename} { set OS $OW ; regsub -all "_" $OS " " OS } ; #rR Attention c'est pas vraiment le OS d'origine ...
set Ligne [PremiereLigneDuFichier $Fichier]
regsub -all " = " $Ligne " " Ligne
if {$OI=="" && ! [regexp {OI=([^=]+)( [A-Z][A-Z]=|$)} $Ligne Match OI]} { FaireLire "merde $Ligne"; continue }
if {$OS=="" && ! [regexp {OS=([^=]+)( [A-Z][A-Z]=|$)} $Ligne Match OS]} { FaireLire "merde $Ligne"; continue }
if {$OX=="" && ! [regexp {OX=([^=]+)( [A-Z][A-Z]=|$)} $Ligne Match OX]} { FaireLire "merde $Ligne"; continue }
regsub -all {[\[\]']} $OS "" OS
set OiCode($OX,OI) $OI
set OiCode($OX,OS) $OS
set GeEs [GeEsFrom $OS]
set OiCode($OX,GeEs) $GeEs
if { ! [info exists NbCops($GeEs)]} { set NbCops($GeEs) 0 }
set Info [format "%-8s %9d %s" $OI $OX $OS]
lappend LesGeEs $GeEs
lappend LesOX $OX
lappend LesOS $OS
incr NbCops($GeEs)
set Filename $OS
regsub -nocase -all {[^a-z0-9\-_]+} $Filename "_" Filename
set OWcalcule [string trim $Filename "_"]
if {$OW!=$OWcalcule && [OuiOuNon "from $Fichier\n$OWcalcule is not $OW\nDo I use $OWcalcule"]} { set OW $OWcalcule }
set OiCode($OX,OW) $OW
set OiCode($OW,OX) $OX
set OiCode($OX,Info) $Info
set OiCode($Info,OX) $OX
set FullFilename "${OI}_${OW}_${OX}"
set OiCode($FullFilename,OX) $OX
set OiCode($OX,FullFilename) $FullFilename
lappend OiCode(ListOfAll,FullFilename) $FullFilename
set FullFilePath "$NotaBeneDir/$FullFilename"
set OiCode($FullFilePath,OX) $OX
set OiCode($OX,FullFilePath) $FullFilePath
lappend OiCode(ListOfAll,FullFilePath) $FullFilePath
}
foreach Fichier [lsort [glob -nocomplain *.fasta]] {
if { ! [regexp {^UP[^_]+_([0-9]+).fasta$} $Fichier Match OX]} {
if { ! [regexp {_([0-9]+).fasta$} $Fichier Match OX]} {
if { ! [regexp {_new_([0-9]+).fasta$} $Fichier]} { FaireLire "Je ne sais pas quoi faire de $Fichier" }
continue
}
if {[info exists OiCode($OX,FullFilename)]} { continue }
set FichierNouveau $Fichier
regsub {.fasta$} $FichierNouveau "" FichierNouveau
append FichierNouveau "_new.fasta"
set OX [ConvertFastaToUniprotStandard $Fichier $FichierNouveau]
if {$OX==""} { continue }
if { ! [regexp {^([0-9]+) is already converted} $OX Match OX]} {
set Original "${Fichier}_Original"
if {[FileAbsent $Original]} { file rename $Fichier $Original }
regsub {_[0-9]+_new.fasta$} $FichierNouveau "_new_$OX.fasta" FichierNouveauNouveau
if {[file exists $FichierNouveauNouveau]} { file delete $FichierNouveauNouveau }
file rename $FichierNouveau $FichierNouveauNouveau
set Fichier $FichierNouveauNouveau
}
}
if {[info exists OiCode($OX,FullFilename)]} { continue }
#FaireLire "Tiens ! Un nouveau \n$Fichier\nMerci de vérifier le programme !!!!!!!!!!!!!!!"
#rR là on traite des nouveaux ...
#rR on le fera en bas avec la ListOf Filename
set Ligne [PremiereLigneDuFichier $Fichier]
regsub -all " = " $Ligne " " Ligne
if { ! [regexp {OS=([^=]+) [A-Z][A-Z]=} $Ligne Match OS]} { FaireLire "ca merde $Ligne"; continue }
regsub -all {[\[\]']} $OS "" OS
set GeEs [GeEsFrom $OS]
set DomaineConnu 0
if {[string index [OiDomain] 0]=="A"} { set GeEs "A$GeEs" ; set DomaineConnu 1 }
if {[string index [OiDomain] 0]=="B"} { set GeEs "B$GeEs" ; set DomaineConnu 1 }
if {[string index [OiDomain] 0]=="E"} { set GeEs "E$GeEs" ; set DomaineConnu 1 }
if {[string index [OiDomain] 0]=="V"} { set GeEs "V$GeEs" ; set DomaineConnu 1 }
if {[string index [OiDomain] 0]=="Q"} { set GeEs "Q$GeEs" ; set DomaineConnu 1 }
if { ! $DomaineConnu } { set GeEs "X$GeEs" }
if { ! [info exists NbCops($GeEs)]} { set NbCops($GeEs) 0 }
set Info [format "%-8s %9d %s" $GeEs $OX $OS]
set OiCode($OX,Info) $Info ; #rR il changera peut-être si deux ont le même GeEs
lappend LesGeEs $GeEs
lappend LesOX $OX
lappend LesOrga $OS
incr NbCops($GeEs)
set Filename $OS
regsub -nocase -all {[^a-z0-9\-_]+} $Filename "_" Filename
set OWcalcule [string trim $Filename "_"]
set OiCode($OX,OW) $OWcalcule
set Filename "${OWcalcule}_${OX}" ; #rR attention ici on ne connait pas encore OI
set OiCode($OX,Filename) $Filename
lappend OiCode(ListOf,Filename) $Filename
set OiCode($OX,Origine) $Fichier
set OiCode($OX,OS) $OS
}
foreach GeEs $LesGeEs OX $LesOX {
lappend OiCode(ListOf,GeEs) $GeEs
set OI ""
set Info $OiCode($OX,Info)
if {! [info exists OiCode($OX,OI)]} {
set OI $GeEs
if {$NbCops($GeEs)==1} {
set OiCode($GeEs,NbCops) 1
} else {
if { ! [info exists OiCode($GeEs,NbCops)]} { set OiCode($GeEs,NbCops) 0 }
incr OiCode($GeEs,NbCops)
set N [expr $OiCode($GeEs,NbCops) - 1]
if {$NbCops($GeEs)<=26} {
set Car [string index $Alphabet $N]
} else {
set D [expr $N/26]
set U [expr $N%26]
set Car "[string index $Alphabet $D][string index $Alphabet $U]"
}
append OI $Car
}
set OiCode($OX,OI) $OI
set Info [format "%-8s %9d %s" $OI $OX $OS]
}
set OW $OiCode($OX,OW)
set OS $OiCode($OX,OS)
set OI $OiCode($OX,OI)
set OiCode($OX,Info) $Info
set OiCode($Info,OX) $OX
lappend OiCode($GeEs,ListOfOX) $OX
lappend OiCode($GeEs,ListOfOI) $OI
lappend OiCode($GeEs,ListOfOS) $OS
lappend OiCode($GeEs,ListOfInfo) $Info
set OiCode($OX,OX) $OX
if {[info exists OiCode($OX,FullFilename)]} { set OiCode($OX,Fasta) "$ProteomesDir/$OiCode($OX,FullFilename)" }
set OiCode($OI,OX) $OX
set OiCode($OS,OX) $OX
lappend LesOS $OS
lappend LesOW $OW
lappend LesOI $OI
}
set LesOX [lsort -integer $LesOX]
set LesOS [lsort -unique $LesOS]
set LesOW [lsort -unique $LesOW]
set LesOI [lsort -unique $LesOI]
foreach OI $LesOI {
set OX $OiCode($OI,OX)
lappend LesInfo $OiCode($OX,Info)
}
if {1} {
foreach Filename $OiCode(ListOf,Filename) {
#if { ! [OuiOuNonMemo "Do I add OI and OX to this new fasta file"]} { Espionne "Skip $Filename" ; continue }
if { ! [regexp {_([0-9]+)$} $Filename Match OX]} { continue }
if { ! [info exists OiCode($OX,OI)]} { FaireLire "Merde $Filename" }
set OI $OiCode($OX,OI)
set FullFilename "${OI}_$Filename"
set FastaFile "NotaBene/$FullFilename"
set OW ""
if { ! [regexp -nocase {^([a-z]+)_(.+)_([0-9]+)$} $FullFilename Match debut OW]} {
FaireLire "$FastaFile has no correct format"
continue
}
set OiCode($OW,OX) $OX
set OS [Tax $OX Name]
regsub -all "'" $OS "" OS
set OiCode($OS,OX) $OX
set Info [format "%-8s %9d %s" $OI $OX $OS]
set OiCode($OW,OX) $OX
set OiCode($Info,OX) $OX
if {[FileAbsent $FastaFile]} {
set Origine $OiCode($OX,Origine)
set Nouveau [RajouteEnFinDeEnteteFasta $Origine " OI=$OI OX=$OX" $FastaFile]
}
set FullFilename "$FastaFile"
set OiCode($OX,FullFilename) $FullFilename
set OiCode($FullFilename,OX) $OX
lappend OiCode(ListOf,FullFilename) $FullFilename
set FullFilePath "$ProteomesDir/$FastaFile"
set OiCode($OX,FullFilePath) $FullFilePath
set OiCode($FullFilePath,OX) $OX
lappend OiCode(ListOf,FullFilePath) $FullFilePath
Espionne $FullFilePath
}
}
set OiCode(ListOfAll,OX) $LesOX
set OiCode(ListOfAll,OI) $LesOI
set OiCode(ListOfAll,OS) $LesOS
set OiCode(ListOfAll,OW) $LesOW
set OiCode(ListOfAll,Info) $LesInfo
foreach K [list OX OI OS OW Info FullFilePath FullFilename] {
set OiCode(ListOf,$K) {}
if { ! [info exists OiCode(ListOfAll,$K)]} { Espionne "OiCode(ListOfAll,$K) does not exist"; continue }
foreach V $OiCode(ListOfAll,$K) {
if {! [info exists OiCode($V,OX)]} {
#Espionne $OX
#Espionne $K
#Espionne $V
continue
}
set OX $OiCode($V,OX)
if {[info exists OiCode($OX,IsBlackListed)]} { continue }
lappend OiCode(ListOf,$K) $V
}
}
OnRevientDuBoulot
return [OiCode $Qui $Quoi]
}
proc OiProteomeSize {Qui} {
global OiProteomeSize
if {[info exists OiProteomeSize($Qui)]} { return $OiProteomeSize($Qui) }
if {[info exists OiProteomeSize("EstCharge")]} { return "" }
set OiProteomeSize("EstCharge") 1
set FichierMemo "[OiCode NotaBeneDir]/proteomesize_memo.txt"
if {[file exists $FichierMemo]} {
array set OiProteomeSize [ContenuDuFichier $FichierMemo]
return [OiProteomeSize $Qui]
}
foreach OX [OiCode ListOf OX] {
set OI [OiCode $OX OI]
set Path [OiCode $OX FullFilePath]
if {[FileAbsent $Path]} { continue }
set L [exec sh -c "grep '^>' $Path | wc -l"]
set OiProteomeSize($OX) $L
set OiProteomeSize($OI) $L
set All "$L $OX $OI"
lappend OiProteomeSize(All) $All
}
Sauve [array get OiProteomeSize] dans $FichierMemo
return [OiProteomeSize $Qui]
}
proc ConvertFastaToUniprotStandard {Fichier NewFichier} {
if { ! [regexp {^.+_([0-9]+).fasta$} $Fichier Match OX]} { return "" }
set OS [Tax $OX Name]
if {$OS==""} { return "" }
if {[regexp "_new_$OX.fasta" $Fichier] && [regexp {OR=} [PremiereLigneDuFichier $Fichier]]} {
Espionne "$Fichier is already converted"
return "$OX is already converted"
}
set LeNew {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp "^>" $Ligne]} { lappend LeNew $Ligne ; continue }
scan $Ligne "%s" Access
regsub -all ">" $Access "" Access
set Gene "" ; regexp { gene=([^ ]+) } $Ligne Match Gene
set Tran "" ; regexp { transcript=([^ ]+) } $Ligne Match Tran
set Prod "" ; regexp { gene_product=([^\|]+) \|} $Ligne Match Prod
#if {$Gene!=""} { set Access "$Gene" }
if {$Tran!=""} { set Access "$Tran" }
set Origine $Ligne
regsub -all ">" $Origine "" Origine
regsub -all "=" $Origine ":" Origine
regsub -all {\|} $Origine "" Origine
regsub -all { +} $Origine " " Origine
set Origine [string trim $Origine]
set TexteProd ""
if { 0 && $Prod!=""} { set TexteProd " $Prod" } ; #rR attention on ne met plus Prod
set TexteGN ""
if {$Gene!=""} { set TexteGN " GN=$Gene" }
set Entete ">${Access}_$OX OS=$OS$TexteGN OR=$Origine"
lappend LeNew $Entete
}
SauveLesLignes $LeNew dans $NewFichier
return $OX
}
proc RefaireLesProteomesNonUniprotStandard {{Domaine ""}} {
if {$Domaine==""} { set Domaine [OiDomain] }
NousAllonsAuBoulot "/genomics/link/OrthoInspector_Proteomes/$Domaine"
foreach Fichier [lsort [glob -nocomplain "*fasta_Original"]] {
Espionne
Espionne $Fichier
set OX ""
if { ! [regexp {_([0-9]+)\.fasta_Original$} $Fichier Match OX]} { continue }
Espionne $OX
foreach NewCree [glob -nocomplain "*_new_$OX.fasta"] {
Espionne $NewCree
file delete $NewCree
}
foreach NB [glob -nocomplain "NotaBene/*_$OX"] {
Espionne $NB
file delete $NB
}
set FastaAConvertir ""
regsub {_Original$} $Fichier "" FastaAConvertir
file copy -force $Fichier $FastaAConvertir
}
OnRevientDuBoulot
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.