Index by: file name |
procedure name |
procedure call |
annotation
gscope_cilio.tcl
(annotations | original source)
#rR gscope_cilio.tcl
#rR Attention : Odile a triché elle a défini des "Clades" Excavata et Archaeplastida MAIS
#rR ces termes n'existent pas dans TaxUniprot
#rR J'ai fait une petite magouille pour la proc JeSuisTonAncetre (utilisé par taxobla pour protall)
#rR Sinon ailleurs on ne devrait pas en avoir besoin.
#rR petite histoire des proteome de OrthoInspector:
#rR ET C'EST PAS FINI !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#rR Tout ce qui suit risque d'être faux car il y a maintenant le proteome que Yannis Nevers a ramené
#rR donc Attention il y a plein de procédures ...OrthoInspector... qui se transforme en ...Yannis...
#rR et ... je répète ... ne vous fiez pas trop aux commentaires !!
#rR .... et 2014/07 Yannis a tout mis dans une base de données docn tot ce qui suit est très approximatif !!!
#rR Benjamin nous fournit
#rR ********* ne sert pas
#rR 1: (mais il ne sert pas pour le moment je le laisse quand même ici pour l'explication)
#rR /dimo/data/orthoinspector_eukaryota_2011_12/orthoinspector_v2_database_dumps_raw_not_pgsql_7-12-2012.tar.gz
#rR - ce fichier fait 34 GO
#rR - je le decompresse dans /biolo/orthoinpector/DataOrthoInspector/database_dumps/
#rR ********* fin ne sert pas
#rR /dimo/data/orthoinspector_eukaryota_2011_12/Orthoinspector_v2_project_data_backup.tar.gz
#rR - ce fichier fait 5.5 GO
#rR - je le decompresse dans /biolo/orthoinpector/DataOrthoInspector/Orthoinspector_v2/
#rR - il contient essentiellement bacteria_archae/ et eukaryota/ qui nous intéresse ici.
#rR - eukaryota/ contient plein de renseignements utiles concernant les organismes et surtout
#rR - all/ contient 261 fasta les protéomes qui nous intéressent.
#rR ATTENTION il y a plein de fichiers qui n'ont pas de CR à la fin.
#rR Je les ai modifiés avec la proc ci-dessous.
#rR J'ai aussi changé cavia_porcellus_9823_23_11_11_merged.fasta
#rR en cavia_porcellus_10141_23_11_11_merged.fasta
#rR car 9823 c'est Sus scrofa !!! ???
#rR Je me suis servi de CreeUneBanqueBlastAvecOrthoInspector pour créer les proteomes
#rR dans /biolo/orthoinpector/DataOrthoInspector/Orthoinspector_v2/eukaryota/proteomes
#rR Pour CilioCarta 2014/07/01 :
#rR si on refait un nouveau projet il faut
#rR - InformeIdEtAcPourTous
#rR - InformeValiDEPourTous
#rR - InformeValiGNPourTous
#rR - InformeIdOiAndAcOiPourTous
#rR - InformeIdRefAndAcRefPourTous
#rR Faire
#rR - BlastPPourTous (penser à mettre BlastParameters.txt dans CilioCarta/blastp)
#rR - DbClustalPourTous All Ortholog (ATTENTION obsolète: Yannis créée lui-même les tfasdecopains 2014/07)
#rR - LeonEtMacsimPourTous
#rR ********* ce paragraphe est obsolète (c'était un essai avec Kirsley)
#rR pour initialiser CilioCarta : (Raymond le 2014/03/28)
#rR Kirsley m'a fourni les fichiers
#rR 101_ciliopathies_desc.csv qui donne des infos generales
#rR 101_ciliopathies_mapping_ids.tsv pour la correspondance ensg enst ensp genename uniprotId
#rR 101_ciliopathies_pep.fasta sequences proteiques
#rR 101_ciliopathies_gene.2.fasta sequences des transcrits correpondants
#rR j'ai commence par integrer tout ca.
#rR Ca s'interroge par CilioDesc Qui Quoi, CilioMappping Qui Quoi, CilioPep Qui Quoi
#rR J'ai créé CilioCarta101.fasta
#rR puis le projet Gscope
#rR et j'integre le tout avec InformeCilioCarta
#rR ********* fin paragraphe obsolète
proc CilioPathyGenes {{Qui ""} {Quoi ""}} {
global CPG
if {[info exists CPG($Qui,$Quoi)]} { return $CPG($Qui,$Quoi) }
if {[info exists CPG("EstCharge")]} { return "" }
set CPG("EstCharge") 1
#set FichierCsv "[GscopeDatabaseDir EHomsa]/fiches/ciliopathy_genes_v1_sans_cr.csv"
set FichierCsv "[GscopeDatabaseDir EHomsa]/fiches/1869CilioPathyGenes_20170510.csv"
set PremiereFois 1
foreach Ligne [LesLignesDuFichier $FichierCsv] {
regsub -all {\"} $Ligne "" Ligne
if {$PremiereFois} {
regsub -all " " $Ligne "_" Ligne
set LesHeaders [split $Ligne ";"]
set PremiereFois 0
continue
}
set LesMots [split $Ligne ";"]
set Gs [lindex $LesMots 1]
regsub -all {[ \?]} $Gs "" Gns
set LesGn [split $Gns "/"]
foreach H $LesHeaders V $LesMots {
foreach Gn $LesGn {
lappend CPG(ListOf,Gn) $Gn
lappend CPG($Gn,$H) $V
}
}
}
set CPG(ListOf,Gn) [lsort -unique $CPG(ListOf,Gn)]
return [CilioPathyGenes $Qui $Quoi]
}
proc CilioPathyGenesOLD {{Qui ""} {Quoi ""}} {
global CPG
if {[info exists CPG($Qui,$Quoi)]} { return $CPG($Qui,$Quoi) }
if {[info exists CPG("EstCharge")]} { return "" }
set CPG("EstCharge") 1
set FichierCsv "[GscopeDatabaseDir EHomsa]/fiches/ciliopathy_genes_v1_sans_cr.csv"
set PremiereFois 1
foreach Ligne [LesLignesDuFichier $FichierCsv] {
regsub -all {\"} $Ligne "" Ligne
if {$PremiereFois} {
regsub -all " " $Ligne "_" Ligne
set LesHeaders [split $Ligne "\t"]
set PremiereFois 0
continue
}
set LesMots [split $Ligne "\t"]
set Gs [lindex $LesMots 2]
regsub -all {[ \?]} $Gs "" Gns
set LesGn [split $Gns "/"]
foreach H $LesHeaders V $LesMots {
foreach Gn $LesGn {
lappend CPG(ListOf,Gn) $Gn
lappend CPG($Gn,$H) $V
}
}
}
set CPG(ListOf,Gn) [lsort -unique $CPG(ListOf,Gn)]
return [CilioPathyGenes $Qui $Quoi]
}
proc AamForCilioPathyGenes {} {
foreach Gn [CilioPathyGenes ListOf Gn] {
set Trouve 0
set Acs [QuestionDeScience GeneQuid "ret GnAc $Gn"]
foreach Ac [split $Acs " "] {
set OX [QuestionDeScience GeneQuid "ret UniprotData $Ac OX"]
if { ! [regexp {NCBI_TaxID=9606( |;)} $OX]} { continue }
#set GnLu [QuestionDeScience GeneQuid "ret AcGn $Ac"]
set GnLu ""
set N [NIAG $Ac N]
if {$N==""} { continue }
set Trouve 1
#Espionne "$Gn $Ac $GnLu $N"
lappend LesNoms $N
}
if { ! $Trouve } { Espionne "Je ne trouve rien pour $Gn" }
}
Espionne $LesNoms
# Espionne [AllAboutMacsimPourTous "[RepertoireDuGenome]/AAM_CilioPathyGenes_OK.tsv" [join $LesNoms ","]]
Espionne [AllAboutMacsimPourTous "[RepertoireDuGenome]/AAM_CilioPathyGenes_1759.tsv" [join $LesNoms ","]]
return $LesNoms
}
proc CilioCartaProject {{Qui ""} {Quoi ""}} {
global PCC
if {[info exists PCC($Qui,$Quoi)]} { return $PCC($Qui,$Quoi) }
if {[info exists PCC("EstCharge")]} { return "" }
set PCC("EstCharge") 1
set LesDeOi [glob -nocomplain "/gstock/*/DeOi"]
set LesProj {}
foreach DeOi $LesDeOi {
set Proj [file tail [file dirname $DeOi]]
lappend LesProj $Proj
}
set LesTypes [list prottfa blastp taxobla descritptifs msf]
set LesProj [lsort $LesProj]
set PCC(ListOf,Project) $LesProj
foreach Pro $LesProj {
set Message [format "%-15s" $Pro]
foreach Type $LesTypes {
set Rep "/gstock/$Pro/$Type"
if {[FileAbsent $Rep]} {
set PCC($Pro,$Type) 0
} else {
cd "/gstock/$Pro/$Type"
set PCC($Pro,$Type) [exec ls -f | wc -l]
}
append Message [format "%10d %s" $PCC($Pro,$Type) $Type]
}
Espionne $Message
}
return [CilioCartaProject $Qui $Quoi]
}
proc InventOi {{Qui ""} {Quoi ""} {Defaut ""} } {
LogWscope [Environ]
set RG $Qui
if { ! [file exists "$RG/beton"]} { return $Defaut }
scan [PremiereLigneDuFichier "$RG/fiches/bornesdespabs"] "%s" Premier
if {[file exists "$RG/blastp/$Premier"] && [file exists "$RG/taxobla/$Premier"]} { return "lightgreen" }
if {[file exists "$RG/taxobla/$Premier"]} { return "yellow" }
return "orange"
}
proc OiName {{Qui ""} {Quoi ""}} {
global OiName
if {[info exists OiName($Qui,$Quoi)]} { return $OiName($Qui,$Quoi) }
if {[info exists OiName("EstCharge")]} {
if {[info exists OiName($Qui,OX)]} {
set OX $OiName($Qui,OX)
if {[info exists OiName($OX,$Quoi)]} { return $OiName($OX,$Quoi) }
}
return ""
}
set OiName("EstCharge") 1
set ProteomeDir "/genomics/link/CilioCarta/banques"
set OiName(ProteomeDir,) $ProteomeDir
set Alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
NousAllonsAuBoulot $ProteomeDir
foreach Orga [lsort [glob *]] {
if {[regexp {\.p|\.log} $Orga]} { continue }
if { ! [regexp {([A-Z][a-z]+)_([a-z]+)_([0-9]+)} $Orga Match G E OX]} { continue }
set Ge [string range $G 0 1]
set Es [string totitle [string range $E 0 1]]
set GeEs "$Ge$Es"
set Info "$GeEs [format %8d $OX] $Orga"
set InfoDe($OX) $Info
set OrgaDe($OX) $Orga
lappend LesGeEs $GeEs
lappend LesOX $OX
lappend LesOrga $Orga
incr NbCops($GeEs)
}
set iAlpha -1
foreach GeEs $LesGeEs OX $LesOX {
set Prefixe $GeEs
if {$NbCops($GeEs)==1} {
set iAlpha -1
} else {
incr iAlpha
append Prefixe [string index $Alphabet $iAlpha]
}
set Orga $OrgaDe($OX)
set OiName($OX,Prefixe) $Prefixe
set OiName($OX,Orga) $OrgaDe($OX)
set OiName($OX,Info) $InfoDe($OX)
set OiName($OX,Fasta) "$ProteomeDir/$OrgaDe($OX)"
set OiName($Prefixe,OX) $OX
set OiName($Orga,OX) $OX
lappend LesPrefixe $Prefixe
}
set LesOXTries [lsort -integer $LesOX]
set LesPrefixe [lsort $LesPrefixe]
set LesInfo {}
foreach Prefixe $LesPrefixe {
set OX $OiName($Prefixe,OX)
lappend LesInfo "[format %-5s $Prefixe] $InfoDe($OX)"
}
set OiName(ListOf,Prefixe) [lsort $LesPrefixe]
set OiName(ListOf,OX) $LesOXTries
set OiName(ListOf,Orga) $LesOrga
set OiName(ListOf,Info) $LesInfo
OnRevientDuBoulot
return [OiName $Qui $Quoi]
}
proc CreeBlastDatabasesWithOrthoinspectorProteomes {} {
NousAllonsAuBoulot "[RepertoireDuGenome]/newbanques"
set LesCrees {}
foreach P [lsort [glob *]] {
if {[regexp {\.p} $P]} { continue }
Espionne $P
exec formatdb -i $P -p T -o
file rename formatdb.log $P.formatdb.log
lappend LesCrees $P
}
OnRevientDuBoulot
return $LesCrees
}
proc RajouteEnFinDeEnteteFasta {{FichierFastaIn ""} {Fin ""} {FichierFastaOut ""} {Clean ""}} {
set MaxLigne 900
set Clean [string equal -nocase $Clean "Clean"]
#rR attention il faut le blanc en début de ce qu'on rajoute
set LeNouveau {}
foreach Ligne [LesLignesDuFichier $FichierFastaIn] {
if {[regexp "^>" $Ligne] && ! [regexp $Fin $Ligne] } {
set F [string length $Fin]
set L [string length $Ligne]
if {$F +$L > 960 } {
set Milieu [expr $L/2]
set Excuse " ... HERE XXXX CHARACTERS WERE CUTTED ... "
set ACouper [expr $L - $MaxLigne + [string length $Excuse]]
regsub "XXXX" $Excuse $ACouper Excuse
set Half [expr $ACouper/2]
set AvantMilieu [expr $Milieu - $Half]
set ApresMilieu [expr $Milieu + $Half]
set LigneCoupee ""
append LigneCoupee [string range $Ligne 0 $AvantMilieu]
append LigneCoupee $Excuse
append LigneCoupee [string range $Ligne $ApresMilieu end]
set Ligne $LigneCoupee
}
append Ligne $Fin
}
if {$Clean} { regsub -all {[\[\]]} $Ligne "" Ligne }
lappend LeNouveau $Ligne
}
SauveLesLignes $LeNouveau dans $FichierFastaOut
return $FichierFastaOut
}
proc RajouteOXDansEnteteFasta {{FichierFastaIn ""} {OX ""} {FichierFastaOut ""}} {
set LeNouveau {}
foreach Ligne [LesLignesDuFichier $FichierFastaIn] {
if {[regexp "^>" $Ligne] && ! [regexp { OX=([0-9]+)} $Ligne] } { append Ligne " OX=$OX" }
lappend LeNouveau $Ligne
}
SauveLesLignes $LeNouveau dans $FichierFastaOut
return $FichierFastaOut
}
proc RajouteOXDansBanqueOrthoinspector {{Qui ""}} {
#rR Quand j'ai créé les protéomes et les banques blast de Orthoinspector j'ai mis TAXID=9606 et non pas OX=9606
#rR Je corrige ça ici
if {$Qui==""} { set Qui "*" }
set RepBank "[RepertoireDuGenome]/banques"
NousAllonsAuBoulot $RepBank
file mkdir "../newbanques"
set LesNouvellesBanques {}
foreach Fichier [lsort [glob $Qui]] {
if {[regexp {\.p} $Fichier]} { continue }
Espionne $Fichier
set Nouveau "../newbanques/$Fichier"
set LeNouveau {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp "^>" $Ligne] } { lappend LeNouveau $Ligne; continue }
if { ! [regexp { TAXID=([0-9]+)} $Ligne Match OX] } { lappend LeNouveau $Ligne; continue }
append Ligne " OX=$OX"
lappend LeNouveau $Ligne
}
SauveLesLignes $LeNouveau dans $Nouveau
lappend LesNouvellesBanques $Fichier
}
OnRevientDuBoulot
return $LesNouvellesBanques
}
proc MajYaProteomes {{TaxId ""}} {
set LesIDs [QuestionDeScience EVImm "ret FromYannis $TaxId IDs"]
set LesACs [QuestionDeScience EVImm "ret FromYannis $TaxId IDs"]
foreach ID $LesIDs AC $LesACs {
if { ! [regexp "_" $ID]} { continue } ;#rR on verra plus tard !!!!!!!!!!!!!!!!!!
set AJour 1
set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"]
if {$LesLignesEMBL=={}} {
set IdAcRef [UniprotHistory $AC]
if {$IdAcRef=="" || IdAcRef=="$ID $AC"} { lappend LesIntrouvablesUniques "$ID $AC"; continue }
scan $IdAcRef "%s %s" IdRef AcRef
set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"]
if {$LesLignesEMBL=={}} { lappend LesIntrouvablesHistoriques "$ID $AC $IdAcRef"; continue }
set AJour 0
}
if {$AJour} { continue }
Espionne "$ID $AC $IdAcRef"
}
}
proc InformeIdYaAndAcYaPourTous {} {
#rR ne sert pas pour le moment car c'est les mêmes que Oi
set TestIt [OuiOuNon "Do I do a test only" 0]
set leLog {}
foreach Nom [ListeDesPABs] {
set Id [ExtraitInfo $Nom "Id:"]
set Ac [ExtraitInfo $Nom "Ac:"]
set TFA [QuestionDeScience EVImm "ret FromYannis $Id tfa"]
set DejaVu($Id) 1
set IdYa ""
if {$TFA!=""} {
set IdYa $Id
} else {
foreach I [UniprotHistory $Ac "IdHis"] {
if {[info exists DejaVu($I)]} { continue }
set DejaVu($I) 1
set TFA [QuestionDeScience EVImm "ret FromYannis $I tfa"]
if {$TFA!=""} { set IdYa $I ; break }
}
}
unset DejaVu
set TFA [QuestionDeScience EVImm "ret FromYannis $Ac tfa"]
set DejaVu($Ac) 1
set AcYa ""
if {$TFA!=""} {
set AcYa $Ac
} else {
foreach A [UniprotHistory $Ac "AcHis"] {
if {[info exists DejaVu($A)]} { continue }
set DejaVu($A) 1
set TFA [QuestionDeScience EVImm "ret FromYannis $A tfa"]
if {$TFA!=""} { set AcYa $A ; break }
}
}
unset DejaVu
set Warning ""
if {$Id!=$IdYa || $Ac!=$AcYa} { set Warning "********" }
lappend LeLog "$Nom\t$Ac\t$AcYa\t$Id\t$IdYa\t$Warning"
if {$IdYa!="" && ! $TestIt} { InformeSansDemander $Nom "IdYa: $IdYA" }
if {$AcYa!="" && ! $TestIt} { InformeSansDemander $Nom "AcYa: $AcYa" }
}
return $LeLog
}
proc InformeIdYaRefAndAcYaRefPourTous {} {
#rR ne sert pas pour le moment car c'est les mêmes que Oi
set TestIt [OuiOuNon "Do I do a test only" 0]
set leLog {}
foreach Nom [ListeDesPABs] {
set Id [ExtraitInfo $Nom "Id:"]
set Ac [ExtraitInfo $Nom "Ac:"]
set IdAcRef [UniprotHistory $Ac "IdAcRef"]
set IdYaRef ""
set AcYaRef ""
scan $IdAcRef "%s %s" IdYaRef AcYaRef
set Warning ""
if {$Id!=$IdYaRef || $Ac!=$AcYaRef} { set Warning "********" }
lappend LeLog "$Nom\t$Ac\t$AcYaRef\t$Id\t$IdYaRef\t$Warning"
if {$IdYaRef!="" && ! $TestIt} { InformeSansDemander $Nom "IdYaRef: $IdYaRef" }
if {$AcYaRef!="" && ! $TestIt} { InformeSansDemander $Nom "AcYaRef: $AcYaRef" }
}
return $LeLog
}
proc MajOiProteomes {{TaxId ""}} {
set LesIDs [QuestionDeScience EVImm "ret FromOrthoInspector $TaxId IDs"]
set LesACs [QuestionDeScience EVImm "ret FromOrthoInspector $TaxId IDs"]
foreach ID $LesIDs AC $LesACs {
if { ! [regexp "_" $ID]} { continue } ;#rR on verra plus tard !!!!!!!!!!!!!!!!!!
set AJour 1
set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"]
if {$LesLignesEMBL=={}} {
set IdAcRef [UniprotHistory $AC]
if {$IdAcRef=="" || IdAcRef=="$ID $AC"} { lappend LesIntrouvablesUniques "$ID $AC"; continue }
scan $IdAcRef "%s %s" IdRef AcRef
set LesLignesEMBL [LaSequenceDesBanques $ID $AC AccessOK "OnVeutEmbl"]
if {$LesLignesEMBL=={}} { lappend LesIntrouvablesHistoriques "$ID $AC $IdAcRef"; continue }
set AJour 0
}
if {$AJour} { continue }
Espionne "$ID $AC $IdAcRef"
}
}
proc InformeIdOiAndAcOiPourTous {} {
set DoIt [OuiOuNon "Do I write to info files"]
set leLog {}
foreach Nom [ListeDesPABs] {
set Id [ExtraitInfo $Nom "Id:"]
set Ac [ExtraitInfo $Nom "Ac:"]
set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $Id tfa"]
set DejaVu($Id) 1
set IdOi ""
if {$TFA!=""} {
set IdOi $Id
} else {
foreach I [UniprotHistory $Ac "IdHis"] {
if {[info exists DejaVu($I)]} { continue }
set DejaVu($I) 1
set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $I tfa"]
if {$TFA!=""} { set IdOi $I ; break }
}
}
unset DejaVu
set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $Ac tfa"]
set DejaVu($Ac) 1
set AcOi ""
if {$TFA!=""} {
set AcOi $Ac
} else {
foreach A [UniprotHistory $Ac "AcHis"] {
if {[info exists DejaVu($A)]} { continue }
set DejaVu($A) 1
set TFA [QuestionDeScience EVImm "ret FromOrthoInspector $A tfa"]
if {$TFA!=""} { set AcOi $A ; break }
}
}
unset DejaVu
set Warning ""
if {$Id!=$IdOi || $Ac!=$AcOi} { set Warning "********" }
lappend LeLog "$Nom\t$Ac\t$AcOi\t$Id\t$IdOi\t$Warning"
if {$IdOi!="" && $DoIt} { InformeSansDemander $Nom "IdOi: $IdOi" }
if {$AcOi!="" && $DoIt} { InformeSansDemander $Nom "AcOi: $AcOi" }
}
return $LeLog
}
proc InformeIdRefAndAcRefPourTous {} {
set TestIt [OuiOuNon "Do I do a test only" 0]
set leLog {}
foreach Nom [ListeDesPABs] {
set Id [ExtraitInfo $Nom "Id:"]
set Ac [ExtraitInfo $Nom "Ac:"]
set IdAcRef [UniprotHistory $Ac "IdAcRef"]
set IdRef ""
set AcRef ""
scan $IdAcRef "%s %s" IdRef AcRef
set Warning ""
if {$Id!=$IdRef || $Ac!=$AcRef} { set Warning "********" }
lappend LeLog "$Nom\t$Ac\t$AcRef\t$Id\t$IdRef\t$Warning"
if {$IdRef!="" && ! $TestIt} { InformeSansDemander $Nom "IdRef: $IdRef" }
if {$AcRef!="" && ! $TestIt} { InformeSansDemander $Nom "AcRef: $AcRef" }
}
return $LeLog
}
proc UniprotHistory {{Qui ""} {Quoi ""}} {
#rR on rend la référence ou l'historique de Id ou Ac
#rR uniprot ne rend que le premier si on lui fournit l'id, mais il rend l'historique avec ac
if {$Quoi==""} { set Quoi "History" }
set Access [string toupper $Qui]
set Url "http://www.uniprot.org/uniprot/$Access.txt?version=*"
set LesTFAs [LesLignesDuFichier $Url]
set IdReference ""
set IdHistory {}
set AcReference ""
set AcHistory {}
set IdAcReference ""
set HistoryOfId {}
set HistoryOfAc {}
foreach Ligne $LesTFAs {
if {[regexp {ID ([^ ]+)} $Ligne Match IDLu]} {
if {$IDLu!=""} {
if {$IdReference==""} { set IdReference $IDLu }
lappend IdHistory $IDLu
lappend HistoryOfId $IDLu
}
}
if {[regexp {AC (.+)} $Ligne Match ACsLus]} {
set ACs $ACsLus
regsub -all {[ ;]+} $ACs " " ACs
set LesACs [split [string trim $ACs] " "]
if {$LesACs!={}} {
lappend HistoryOfAc $ACsLus
if {$AcReference==""} {
set AcReference [lindex $LesACs 0]
if {$AcReference!=$Qui} { return [UniprotHistory $AcReference $Quoi] }
}
foreach AC $LesACs {
lappend AcHistory $AC
}
}
}
}
set IdHistory [ListeSansDoublon $IdHistory]
set AcHistory [ListeSansDoublon $AcHistory]
set IdAcReference "$IdReference $AcReference"
if {[regexp -nocase "^IdAcR" $Quoi]} { set Quoi "IdAcReference" }
if {[regexp -nocase "^IdR" $Quoi]} { set Quoi "IdReference" }
if {[regexp -nocase "^IdH" $Quoi]} { set Quoi "IdHistory" }
if {[regexp -nocase "^AcR" $Quoi]} { set Quoi "AcReference" }
if {[regexp -nocase "^AcH" $Quoi]} { set Quoi "AcHistory" }
if {[info exists $Quoi]} { return [set $Quoi] }
if {[regexp -nocase "^H" $Quoi]} {
set LeHis {}
foreach A $HistoryOfAc I $HistoryOfId {
lappend LeHis "$I\t$A"
}
set LeHis [ListeSansDoublon $LeHis]
return $LeHis
}
return ""
}
proc PABsDuIdOuAc {IdOuAc {Science ""}} {
global PABsDuIdOuAc
if { $Science!="" && ! [OnTraite $Science] } {
return [QuestionDeScience Science "ret PABsDuIdOuAc $IdOuAc"]
}
set IDOUAC [string toupper $IdOuAc]
if {[info exists PABsDuIdOuAc($IDOUAC)]} { return $PABsDuIdOuAc($IDOUAC) }
if {[info exists PABsDuIdOuAc("EstCharge")]} { return "" }
set PABsDuIdOuAc("EstCharge") 1
foreach Nom [ListeDesPABs] {
set Id [ExtraitInfo $Nom "Id:"]
if {$Id!=""} { set ID [string toupper $Id] ; lappend PABsDuIdOuAc($ID) $Nom }
set Ac [ExtraitInfo $Nom "Ac:"]
if {$Ac!=""} { set AC [string toupper $Ac] ; lappend PABsDuIdOuAc($AC) $Nom }
}
return [PABsDuIdOuAc $IdOuAc]
}
proc OiOrthologsFromCilioCarta {Query {Action ""} {OrganismList ""}} {
global OiOrthologsFrom
#rR Action can be IDs, ACs, Contains_P12345
if {$Action==""} { set Action "IDs" }
if {$Query==""} { return "" }
if {[regexp {^CIL[0-9]+$} $Query]} {
set Nom $Query
} else {
set Nom [PABsDuIdOuAc $Query "CilioCarta"]
}
if {$Nom==""} { return "" }
set Action [string toupper $Action]
if {[info exists OiOrthologsFrom($Nom,$Action)]} { return $OiOrthologsFrom($Nom,$Action) }
if {[info exists OiOrthologsFrom($Nom,ESTCHARGE)]} {
if {[regexp {CONTAINS_(.+)} $Action Match Access]} {
if {[info exists OiOrthologsFrom($Access,REFERENCE)]} {
return [expr [lsearch $Nom $OiOrthologsFrom($Access,REFERENCE)] >= 0]
}
return 0
}
return ""
}
set OiOrthologsFrom($Nom,ESTCHARGE) 1
#rR on peut prendre Oi au lieu de Ya car c'est les mêmes
if {[OnTraite "CilioCarta"]} {
set IdQuery [ExtraitInfo $Nom "IdOi:"]
set AcQuery [ExtraitInfo $Nom "AcOi:"]
} else {
set IdQuery [QuestionDeScience "CilioCarta" "ret ExtraitInfo $Nom IdOi:"]
set AcQuery [QuestionDeScience "CilioCarta" "ret ExtraitInfo $Nom AcOi:"]
}
set LesHeader [OiLesTFAsDesOrthologs $IdQuery $OrganismList "GetHeader"]
foreach H $LesHeader {
regsub ">" $H "" H
scan $H "%s %s" A B
if {[regexp {\|} $A]} {
lassign [split $A "|"] Banque Ac Id
} else {
set Id $A
set Ac $B
}
#rR 2014/07/08 pour éventuellement prendre la ref plus récente dans Yannis
if {[OnTraite "EVImm"]} {
set TFA [FromYannis $Ac "tfa"]
} else {
set TFA [QuestionDeScience "EVImm" "ret FromYannis $Ac tfa"]
}
if {$TFA==""} {
set IdAcNow [UniprotHistory $Id "IdAcRef"]
if {$IdAcNow==""} { continue }
lassign [split $IdAcNow "\t"] Id Ac
}
set ID [string toupper $Id]
set AC [string toupper $Ac]
if {$Id!=""} { lappend OiOrthologsFrom($Nom,IDS) $Id }
if {$Ac!=""} { lappend OiOrthologsFrom($Nom,ACS) $Ac }
lappend OiOrthologsFrom($ID,REFERENCE) $Nom
lappend OiOrthologsFrom($AC,REFERENCE) $Nom
}
return [OiOrthologsFromCilioCarta $Query $Action $OrganismList]
}
proc CompareOrganismsOiYannis {} {
foreach TOI [OiOrganism ListOf TaxId] {
set TYA [YannisOrganism $TOI TaxId]
# Espionne "$TOI $TYA"
}
Espionne ""
foreach TYA [YannisOrganism ListOf TaxId] {
set TOI [OrganismFromOrthoInspector $TYA TaxId]
set FOS [YannisOrganism $TYA FullOs]
set OS [YannisOrganism $TYA OS]
if {$TOI==""} {
set TOI [OrganismFromOrthoInspector $OS TaxId]
set FOSoi [OrganismFromOrthoInspector $TOI FullOs]
Espionne "$TYA $TOI $FOS $FOSoi"
}
}
}
proc YannisOrganism {{Qui ""} {Quoi ""}} {
global YannisOrganism
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Keys" }
set LesKeys [list TaxId FullOs Filename OS Strain Keys]
foreach K $LesKeys {
if {[string equal -nocase $Quoi $K]} { set Quoi $K ; break }
}
if {[info exists YannisOrganism($Qui,$Quoi)]} { return $YannisOrganism($Qui,$Quoi) }
if {[info exists YannisOrganism("EstCharge")]} {
if {[info exists YannisOrganism($Qui,Id)]} {
set Id $YannisOrganism($Qui,Id)
if {[info exists YannisOrganism($Id,$Quoi)]} { return $YannisOrganism($Id,$Quoi) }
}
return ""
}
set YannisOrganism("EstCharge") 1
set Rep "/home/nevers/StageJuin/Proteomes"
set YannisOrganism(Rep,) $Rep
NousAllonsAuBoulot $Rep
set LesFichiersTfa [lsort [glob -nocomplain "*.tfa"]]
foreach Fichier $LesFichiersTfa {
if { ! [regexp {([0-9]+)_([A-Z][a-z]+)_([a-z\.\-]+)_(.*)} $Fichier Match TaxId G E R]} { FaireLire "Bas $Fichier"; continue }
set Filename "$Rep/$Fichier"
set OS "${G}_$E"
set Strain $R
regsub "\.tfa$" $Strain "" Strain
if {$Strain=="-"} { set Strain "" }
set FullOs "$TaxId $G $E $Strain"
lappend YannisOrganism(ListOf,TaxId) $TaxId
lappend YannisOrganism(ListOf,OS) $OS
lappend YannisOrganism(ListOf,Strain) $Strain
lappend YannisOrganism(ListOf,Filename) $Fichier
lappend YannisOrganism(ListOf,FullOs) $FullOs
set YannisOrganism($TaxId,TaxId) $TaxId
set YannisOrganism($TaxId,OS) $OS
set YannisOrganism($TaxId,FullOs) $FullOs
set YannisOrganism($TaxId,Strain) $Strain
set YannisOrganism($TaxId,Filename) $Filename
lappend YannisOrganism($OS,TaxId) $TaxId
set YannisOrganism($FullOs,TaxId) $TaxId
set YannisOrganism($Filename,TaxId) $TaxId
}
set YannisOrganism(ListOf,Keys) $LesKeys
set YannisOrganism(ListOf,TaxId) [lsort -integer $YannisOrganism(ListOf,TaxId)]
set YannisOrganism(ListOf,OS) [lsort -unique $YannisOrganism(ListOf,OS)]
set YannisOrganism(ListOf,FullOs) [lsort $YannisOrganism(ListOf,FullOs)]
OnRevientDuBoulot
return [YannisOrganism $Qui $Quoi]
}
proc OiOrganism {{Qui ""} {Quoi ""}} {
global OiOrganism
#rR on utilise oi_client -organism_ids pour avoir les correspondances Id de Orthoinspector et TaxId
#rR au premier appel on charge TaxId dasn EVImm ça peut être long
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Keys" }
set LesKeys [list Id Identifier TextOs OS TaxId Keys]
foreach K $LesKeys {
if {[string equal -nocase $Quoi $K]} { set Quoi $K ; break }
}
if {[info exists OiOrganism($Qui,$Quoi)]} { return $OiOrganism($Qui,$Quoi) }
if {[info exists OiOrganism("EstCharge")]} {
if {[info exists OiOrganism($Qui,Id)]} {
set Id $OiOrganism($Qui,Id)
if {[info exists OiOrganism($Id,$Quoi)]} { return $OiOrganism($Id,$Quoi) }
}
return ""
}
set OiOrganism("EstCharge") 1
#rR il faut mettre le catch sinon ca marche pas
catch {set Texte [exec oi_client -organism_ids]} Texte
foreach Ligne [split $Texte "\n"] {
if { ! [regexp -nocase {id=([0-9]+)[ \t]+identifier=([A-Z0-9]+)[ \t]+(.*)} $Ligne Match Id Identifier TextOs]} { continue }
scan $TextOs "%s %s" G E
set OS "${G}_$E"
set TaxId [Tax $OS]
if {$TaxId==""} {
if {$OS=="Micromonas_sp."} { set TaxId 296587 }
if {$OS=="Salpingoeca_sp."} { set TaxId 946362 }
}
if {$TaxId==""} { set TaxId 999999 }
lappend OiOrganism(ListOf,Id) $Id
lappend OiOrganism(ListOf,Identifier) $Identifier
lappend OiOrganism(ListOf,TextOs) $TextOs
lappend OiOrganism(ListOf,OS) $OS
lappend OiOrganism(ListOf,TaxId) $TaxId
set OiOrganism($Id,Id) $Id
set OiOrganism($Identifier,Id) $Id
set OiOrganism($TextOs,Id) $Id
set OiOrganism($OS,Id) $Id
set OiOrganism($TaxId,Id) $Id
set OiOrganism($TaxId,TaxId) $TaxId
set OiOrganism($Id,Identifier) $Identifier
set OiOrganism($Id,TextOs) $TextOs
set OiOrganism($Id,OS) $OS
set OiOrganism($Id,TaxId) $TaxId
}
set OiOrganism(ListOf,Keys) $LesKeys
set OiOrganism(ListOf,Id) [lsort -integer $OiOrganism(ListOf,Id)]
set OiOrganism(ListOf,TaxId) [lsort -integer $OiOrganism(ListOf,TaxId)]
set OiOrganism(ListOf,Identifier) [lsort $OiOrganism(ListOf,Identifier)]
set OiOrganism(ListOf,OS) [lsort $OiOrganism(ListOf,OS)]
set OiOrganism(ListOf,TextOs) [lsort $OiOrganism(ListOf,TextOs)]
return [OiOrganism $Qui $Quoi]
}
proc OiLesTFAsDesOrthologs {{Query ""} {OrgaList ""} {Quoi ""}} {
if {$OrgaList=="" || [regexp -nocase "Defau" $OrgaList]} { set OrgaList [OiOrgaList]}
set FicOut "[TmpFile].oi"
exec /biolo/orthoinspector/oi_client -mode single -query $Query -organism_list $OrgaList -outfmt 5 -out $FicOut
if {[FileAbsent $FicOut]} { return {} }
set LesLignes [LesLignesDuFichier $FicOut]
file delete $FicOut
if {$Quoi=="GetHeader" || $Quoi=="GetAccess"} {
set LeRetour {}
foreach Ligne $LesLignes {
if { ! [regexp ">" $Ligne]} { continue }
if {$Quoi=="GetHeader"} { lappend LeRetour $Ligne ; continue }
scan [string range $Ligne 1 end] "%s" Access
if {$Quoi=="GetAccess"} { lappend LeRetour $Access ; continue }
}
return $LeRetour
}
return $LesLignes
}
proc OrganismListForCilioCode {{GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "TaxId" }
set Fichier [Fiches "ListOfTaxIdCilioCode.txt"]
set LesTaxId {}
foreach Ligne [LesLignesDuFichier $Fichier] {
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
lappend LesTaxId $Ligne
}
set AsText [regexp -nocase "AsText" $GetWhat]
set WithComma [regexp -nocase "AsTextWithComma" $GetWhat]
set WithSpace [regexp -nocase "AsTextWithSpase" $GetWhat]
regsub -nocase "AsText.*" $GetWhat "" GetWhat
set Liste {}
if {[regexp -nocase "^TaxId" $GetWhat]} {
set Liste $LesTaxId
} else {
foreach TaxId $LesTaxId {
set Info [OiOrganism $TaxId $GetWhat]
if {$Info==""} { continue }
lappend Liste $Info
}
}
if { ! $AsText } { return $Liste }
set Sep ","
if {$WithComma} { set Sep "," }
if {$WithSpace} { set Sep " " }
return [join $Liste $Sep]
}
proc OiOrgaList {{GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "GetIdAsTextWithComma" }
# set OrgaList "82 210 254 140 66 101 72 69 184 9 152 197 49 170 194 37 118 88 169 59 225 119 124 141 138 32 200 255 151 50 18 20 163 186 249 189 99 223 77 221 114 155 188"
set OrgaList "101,104,109,114,115,116,117,118,119,122,124,125,128,13,138,14,140,141,142,143,146,149,15,151,152,155,159,161,163,169,170,173,174,18,183,184,186,188,189,190,194,197,2,20,200,203,210,212,214,217,22,221,222,223,225,226,232,239,240,242,244,245,246,247,248,249,254,255,257,259,26,29,3,32,33,37,39,4,41,49,50,51,53,59,6,60,65,66,67,69,7,72,77,78,82,88,9,90,92,99"
set OrgaList [split $OrgaList ", "]
set OrgaList [lsort -integer $OrgaList]
if {$GetWhat=="GetIdAsTextWithComma"} { return [join $OrgaList ","] }
if {$GetWhat=="GetIdAsTextWithBlank"} { return [join $OrgaList " "] }
set Keys [OiOrganism ListOf Keys]
foreach K $Keys {
if {[regexp -nocase "Get${K}As" $GetWhat]} {
set Li {}
foreach O $OrgaList {
set V [OiOrganism $O $K]
lappend Li "$O=$V"
}
if {[regexp "AsTextWithComma" $GetWhat]} { return [join $Li ","] }
if {[regexp "AsTextWithBlank" $GetWhat]} { return [join $Li " "] }
return $Li
}
}
return $OrgaList
}
proc CorrigeLesDescriptifsEnSupprimantRootEtCellularOrganism {} {
set LesNouveaux {}
foreach Nom [ListeDesPABs] {
set FichierDescriptif [GscopeFile $Nom descriptifs]
if {[FileAbsent $FichierDescriptif]} { continue }
set LeNew {}
set YaDuNeuf 0
foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
set New $Ligne
if { [regexp {OC\:root; cellular organisms; } $New]} {
incr YaDuNeuf 1
regsub {OC\:root; cellular organisms; } $New "OC:" New
}
if { [regexp {Opisthokonta; } $New]} {
incr YaDuNeuf 1
regsub {Opisthokonta; } $New "" New
}
lappend LeNew $New
}
if {$YaDuNeuf} {
Espionne "$Nom $YaDuNeuf"
SauveLesLignes $LeNew dans $FichierDescriptif
lappend LesNouveaux $FichierDescriptif
}
}
return $LesNouveaux
}
proc CorrigeLesDescriptifs {} {
set LesOS [QuestionDeScience "CilioCarta" "FromOrthoInspector ListOf OS"]
set LesNouveaux {}
foreach Nom [ListeDesPABs] {
set FichierDescriptif [GscopeFile $Nom descriptifs]
if {[FileAbsent $FichierDescriptif]} { continue }
set LeNew {}
set YaDuNeuf 0
foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
if { ! [regexp {OS\: GN\:} $Ligne]} { lappend LeNew $Ligne; continue }
if { ! [regexp {DE\:([A-Z][a-z]+) ([a-z\.]+) } $Ligne Match G E]} { lappend LeNew $Ligne; continue }
set YaDuNeuf 1
set New $Ligne
regsub {OS\: GN\:} $New "OS:$G $E GN:" New
regsub {DE\:([A-Z][a-z]+) ([a-z\.]+) } $New "DE:" New
}
if {$YaDuNeuf} {
SauveLesLignes $LeNew dans $FichierDescriptif
lappend LesNouveaux $FichierDescriptif
}
}
return $LesNouveaux
}
proc VerifieLeFasta Fichier {
#rR j'ai ecrit ca pour voir pourquoi le proteome de OrthoInspector etait mauvais ... mais c'était la faute a formatdb
set n 0
set t 0
foreach Ligne [LesLignesDuFichier $Fichier] {
incr t
if {[regexp {^>([^ ]+)( |$)} $Ligne Match Access]} {
if { ! [regexp -nocase {^[A-Z0-9_\-\:\.]+$} $Access]} { FaireLire "Wrong $Access" }
set ACCESS [string toupper $Access]
if {[info exists DejaVu($ACCESS)]} { FaireLire "DejaVu $Access" }
set DejaVu($ACCESS) 1
if {[string length $Access]>50} { FaireLire "long $Access" }
if {[string length $Ligne]>1000} { FaireLire "long $Ligne" }
incr n
lappend LeNouveau $Ligne
continue
}
if {[regexp -nocase {[^A-Z]} $Ligne]} { FaireLire "wrong seq for $Access\n$Ligne" }
if {$Ligne==""} { continue }
lappend LeNouveau $Ligne
}
SauveLesLignes $LeNouveau dans $Fichier.NEW
return "$t lines for $n accesses"
}
proc TailleDeLaBanque {Banque} {
set Taille 0
foreach F [glob -nocomplain $Banque.*] {
set Size [file size $F]
incr Taille $Size
}
return "$Taille [expr $Taille/1000 + 1]KO [expr $Taille/1000000 + 1]MO [expr $Taille/1000000000 + 1]GO"
}
proc CilioCartaVersion {} {
return 1.2
}
proc CilioCartaDir {} {
return "/genomics/link/CilioCarta/DeKirsley/101"
}
proc CilioDesc {{Qui ""} {Quoi ""}} {
global CilioDesc
if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }
if {[info exists CilioDesc($Qui,$Quoi)]} { return $CilioDesc($Qui,$Quoi) }
if {[info exists CilioDesc("EstCharge")]} { return "" }
set CilioDesc("EstCharge") 1
set FichierCsv "[CilioCartaDir]/101_ciliopathies_desc.csv"
set CilioDesc(filename,) $FichierCsv
LoadTxlWithRowsOfCells $FichierCsv CilioDesc 0 "\t"
set CilioDesc(ListOf,Gene) $CilioDesc(ListAllPlease,)
set CilioDesc(ListOf,Header) $CilioDesc(ListHeaderPlease,)
return [CilioDesc $Qui $Quoi]
}
proc CilioMapping {{Qui ""} {Quoi ""}} {
global CilioMapping
if {$Qui==""} { set Qui "ListOf"; set Quoi "Keys" }
if {[info exists CilioMapping($Qui,$Quoi)]} { return $CilioMapping($Qui,$Quoi) }
if {[info exists CilioMapping("EstCharge")]} {
if {[info exists CilioMapping($Qui,GI)] \
&& [info exists CilioMapping($CilioMapping($Qui,GI),$Quoi)]} {
return $CilioMapping($CilioMapping($Qui,GI),$Quoi)
}
return ""
}
set CilioMapping("EstCharge") 1
set FichierCsv "[CilioCartaDir]/101_ciliopathies_mapping_ids.tsv"
set CilioMapping(filename,) $FichierCsv
LoadTxlWithRowsOfCells $FichierCsv CilioMapping 0 "\t"
set CilioMapping(ListOf,GI) $CilioMapping(ListAllPlease,)
set CilioMapping(ListOf,Header) $CilioMapping(ListHeaderPlease,)
set LesH [list gene_stable_id gene_display_label transcript_stable_id translation_stable_id UniProt_ID]
set LesK [list GI GN TI PI AC ]
set CilioMapping(ListOf,Keys) $LesK
foreach GI $CilioMapping(ListOf,GI) {
set CilioMapping($GI,All) "$GI"
foreach H $LesH K $LesK {
set $K [string trim $CilioMapping($GI,$H)]
append CilioMapping($GI,All) "\t[set $K]"
lappend CilioMapping(ListOf,$K) [set $K]
set CilioMapping($GI,$K) [set $K]
set CilioMapping([set $K],GI) $GI
}
}
return [CilioMapping $Qui $Quoi]
}
proc CilioPep {{Qui ""} {Quoi ""}} {
global CilioPep
if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }
if {[info exists CilioPep($Qui,$Quoi)]} { return $CilioPep($Qui,$Quoi) }
if {[info exists CilioPep("EstCharge")]} { return "" }
set CilioPep("EstCharge") 1
set Fichier "[CilioCartaDir]/101_ciliopathies_pep.fasta"
set LesK [list AC ID GN GI TI PI DE SO PM CS LO CN SQ FA]
set LesG [list AC ID ValiGN ENSG ENST ENSP ValiDE SourceOfDef PubMed CiliomeStudies Location CuratorsNote "" ""]
set CilioPep(ListOf,Header) $LesK
set CilioPep(ListOf,GscopeHeader) $LesG
set LesLignes [LesLignesDuFichier $Fichier]
lappend LesLignes ">fin"
set PremiereFois 1
foreach Ligne $LesLignes {
if { ! [regexp ">" $Ligne]} {
lappend LaSeq $Ligne
continue
}
if {$PremiereFois} {
set PremiereFois 0
set LaSeq {}
} else {
set SQ [join $LaSeq "\n"]
set LaSeq {}
set FA [SequenceFormatTFA $SQ "$GN $DE ID=$ID AC=$AC PI=$PI"]
foreach K $LesK {
set CilioPep($GI,$K) [set $K]
lappend CilioPep(ListOf,$K) [set $K]
}
}
if {$Ligne==">fin"} { break }
# AC ID DE OS GN
#sp|Q8N157|AHI1_HUMAN Jouberin OS=Homo sapiens GN=AHI1 PE=1 SV=1
if { ! [regexp {([^ ]+) ([^=]+)} $Ligne Match Access DE]} { FaireLire "ca merde pour $Ligne" }
set AC [lindex [split $Access "|"] 1]
set ID [lindex [split $Access "|"] 2]
set DE [string trim [string range $DE 0 end-2]]
regsub { PE=.*} $Ligne "" Ligne
set GN [string trim [StringApres "GN=" dans $Ligne]]
regsub { GN=.*} $Ligne "" Ligne
set OS [StringSuivant "OS=" dans $Ligne]
# Espionne "$AC $ID $GN $OS / $DE"
set GI [CilioMapping $AC GI]
set TI [CilioMapping $AC TI]
set PI [CilioMapping $AC PI]
set gn [CilioMapping $AC GN] ; if {$gn!=$GN} { FaireLire "dans mapping $AC/$gn/!=/$GN/$AC [CilioMapping $AC All]" }
set gn [CilioDesc $GI Gene_Name] ; if {0 && $gn!=$GN} { FaireLire "dans desc $GI/$gn/!=$GN/" }
set ei [CilioDesc $GI "Ensembl_ID"] ; if {0 && $ei!=$GI} { FaireLire "Ca merde pour Ensembl_Id=$ei= et GI=$GI=" }
set de [CilioDesc $GI "Description"]
set SO ""
if {[regexp {([^\[]+) \[Source:(.*)\]} $de Match NewDE SO]} {
set de [string trim $NewDE]
set SO [string trim $SO]
}
if {0 && $de!=$DE} {
regsub "protein " $DE "" DEcoupe
if {[string trim $de]!=[string trim $DEcoupe]} { FaireLire "Ca merde pour \n$de\n$DEcoupe" }
}
set PM [CilioDesc $GI "PubMed_IDs"]
set CS [CilioDesc $GI "Ciliome_studies"]
set LO [CilioDesc $GI "Localisation"]
set CN [CilioDesc $GI "Curators_Note"]
}
foreach K $LesK {
set CilioPep(ListOf,$K) [lsort -unique $CilioPep(ListOf,$K)]
}
foreach GI $CilioPep(ListOf,GI) {
set GN $CilioPep($GI,GN)
set PI $CilioPep($GI,PI)
foreach K $LesK {
set CilioPep($GN,$K) $CilioPep($GI,$K)
set CilioPep($PI,$K) $CilioPep($GI,$K)
}
}
return [CilioPep $Qui $Quoi]
}
proc InformeParProtemblPourTous {{DoIt ""}} {
if {$DoIt==""} {
if {[OuiOuNon "Do I really do the updates"]} { set DoIt "DoIt" }
}
set DoIt [string equal -nocase $DoIt "DoIt"]
foreach Nom [ListeDesPABs] {
set FicEmbl [GscopeFile $Nom protembl]
set LesLignesEMBL [LesLignesDuFichier $FicEmbl]
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
set LesK [list ID AC DE GN OS OC OX]
foreach K $LesK {
set V [set $K]
if {$V==""} { continue }
set ClefInfo $K
if {$K=="ID"} {
if {$ID==$Nom} {
#rR pour CilioCarta on va chercher l'ID dans le prottfa
set FicTfa [GscopeFile $Nom prottfa]
set Header [PremiereLigneDuFichier $FicTfa]
scan $Header "%s %s" N I
set A "" ; set B ""; set C ""
lassign [split $I "|"] A B C
if {$C!=""} {
set ID $C
} elseif {$B!=""} {
set ID $B
} else {
set ID $A
}
}
set V $ID
set ClefInfo "Id"
}
if {$K=="AC"} { set ClefInfo "Ac" }
if {$K=="DE"} { set ClefInfo "ValiDE" }
if {$K=="GN"} { set ClefInfo "ValiGN" }
if {$DoIt} {
InformeSansDemander $Nom "=$ClefInfo: $V"
} else {
Espionne "InformeSansDemander $Nom =$ClefInfo: $V"
}
lappend LesInfos "$Nom =$ClefInfo: $V"
}
}
return $LesInfos
}
proc InformeCilioCarta {} {
FaireLire "Merci de vérifier cette proc, elle est peut-être obsolète"
foreach Nom [ListeDesPABs] {
set FicTfa [GscopeFile $Nom prottfa]
scan [PremiereLigneDuFichier $FicTfa] "%s %s" N Gn
set GN [CilioPep $Gn GN]
if {$Gn!=$GN} { FaireLire "Ca merde pour $Nom $Gn!=$GN" }
#AC ID GN GI TI PI DE SO PM CS LO CN SQ FA"
foreach K [CilioPep ListOf Header] G [CilioPep ListOf GscopeHeader] {
if {$G==""} { continue }
set V [CilioPep $GN $K]
InformeSansDemander $Nom "$G: $V"
}
}
return
}
proc CreeProjetGscopeCilioCarta {} {
set LeTFAs [CilioPep ListOf FA]
set FichierFasta [SauveLesLignes $LeTFAs dans "[CilioCartaDir]/CilioCarta.fasta"]
return [Espionne "$FichierFasta est créé.\nMaitenant il faut faire \nsetgscoperr CilioCarta\n et lancer \ngscope\n puis gscope InformeCilioCarta"]
}
######################################## FromOrthoInspector
proc CompareOrganismFromOrthoInspectorAndYannis {} {
foreach TYA [OrganismFromYannis ListOf TaxId] {
set OSYA [OrganismFromYannis $TYA OS]
set FullOsYA [OrganismFromYannis $TYA FullOs]
set TOI [OrganismFromOrthoInspector $TYA TaxId]
if {$TOI==""} {
set TOI [OrganismFromOrthoInspector $FullOsYA TaxId]
if {$TOI==""} {
set TOI [OrganismFromOrthoInspector $FullOsYA TaxId]
if {$TOI==""} { FaireLire "Je ne trouve pas\n$TYA $FullOsYA\ndans OrthoInspector" ; continue }
}
}
set FullOsOI [OrganismFromOrthoInspector $TYA FullOs]
if {$FullOsYA==$FullOsOI} { continue }
Espionne "$FullOsYA\n$FullOsOI"
Espionne
}
}
proc OrganismFromOrthoInspector {{Qui ""} {Quoi ""}} {
#rR on lit le nom du fichier qui contient le taxid et l'os mais avec le strain qui peut-être n'importe quoi.
global OFOI
set QUI [string toupper $Qui]
regsub " " $QUI "_" QUI
set QUOI [string toupper $Quoi]
if {[info exists OFOI($QUI,$QUOI)]} { return $OFOI($QUI,$QUOI) }
if {[info exists OFOI("EstCharge")]} {
if {[info exists OFOI($QUI,TAXID)]} {
set LaReponse {}
foreach TaxId $OFOI($QUI,TAXID) {
if {[info exists OFOI($TaxId,$QUOI)]} { lappend LaReponse $OFOI($TaxId,$QUOI) }
}
return $LaReponse
}
return ""
}
set OFOI("EstCharge") 1
set Rep "/biolo/orthoinspector/DataOrthoinspector/Orthoinspector_v2/eukaryota/all"
set OFOI(REP,) $Rep
foreach Fichier [lsort [glob -nocomplain "$Rep/*.fasta"]] {
set Queue [file tail $Fichier]
#if {[regexp {^[0-9]} $Queue]} { continue }
set OsDuFichier ""
set TaxIdDuFichier ""
regsub {\.fasta$} $Queue "" FullName
set G ""
set E ""
set T ""
set S ""
if {[regexp {([a-z]+)_([a-z\-\.]+)_([0-9]+)_(.+)} $FullName Match G E T S]} {
set G [string totitle $G]
set OsDuFichier "${G}_$E"
set FullOs $OsDuFichier
set TaxIdDuFichier $T
set Strain $S
if {$Strain!=""} { append FullOs "_$Strain" }
}
if {[regexp {([0-9]+)_([A-Z][a-z]+)_([a-z\-\.]+)(_(.*)|$)} $FullName Match T G E X S]} {
set TaxIdDuFichier $T
set OsDuFichier "${G}_$E"
set FullOs $OsDuFichier
set Strain $S
if {$Strain!=""} { append FullOs "_$Strain" }
}
# if {$TaxIdDuFichier=="9823" && $OsDuFichier=="Cavia_porcellus"} { set TaxIdDuFichier "10141" }
if {[info exists DejaVu($TaxIdDuFichier)]} { FaireLire "DejaVu $TaxIdDuFichier" }
set DejaVu($TaxIdDuFichier) 1
set OsFromTax [Tax $TaxIdDuFichier]
regsub " " $OsFromTax "_" OsFromTax
set AfficheOsFromTax "" ; if {$OsFromTax!="$OsDuFichier"} { set AfficheOsFromTax $OsFromTax }
set TaxId $TaxIdDuFichier
set Os $OsDuFichier
regsub "_" $Os " " $Os
set OFOI($TaxId,TAXID) $TaxId
set OFOI($TaxId,FULLNAME) $FullName
set OFOI($TaxId,FILENAME) $Fichier
set OFOI($TaxId,OS) $Os
set OFOI($TaxId,FULLOS) $FullOs
set OFOI($TaxId,STRAIN) $Strain
set OFOI($TaxId,OSFROMTAX) [Tax $TaxId]
set FULLNAME [string toupper $FullName]
set FULLOS [string toupper $FullOs]
set OS [string toupper $Os]
set STRAIN [string toupper $Strain]
set OFOI($FULLNAME,TAXID) $TaxId
set OFOI($FULLOS,TAXID) $TaxId
lappend OFOI($OS,TAXID) $TaxId
lappend OFOI($STRAIN,TAXID) $TaxId
lappend OFOI(LISTOF,TAXID) $TaxId
lappend OFOI(LISTOF,FULLNAME) $FullName
lappend OFOI(LISTOF,FULLOS) $FullOs
# lappend OFOI(LISTOF,OS) $Os
lappend OFOI(LISTOF,STRAIN) $Strain
lappend OFOI(LISTOF,FILENAME) $Fichier
}
set OFOI(LISTOF,FULLOS) [lsort -unique $OFOI(LISTOF,FULLOS)]
set OFOI(LISTOF,FULLNAME) [lsort -unique $OFOI(LISTOF,FULLNAME)]
set OFOI(LISTOF,FILENAME) [lsort -unique $OFOI(LISTOF,FILENAME)]
set OFOI(LISTOF,STRAIN) [lsort -unique $OFOI(LISTOF,STRAIN)]
foreach FullOS $OFOI(LISTOF,FULLOS) {
lassign [split $FullOS "_"] G E
set OS "$G $E"
lappend OFOI(LISTOF,OS) $OS
}
return [OrganismFromOrthoInspector $Qui $Quoi]
}
proc OrganismFromYannis {{Qui ""} {Quoi ""}} {
#rR on lit le nom du fichier qui contient le taxid et l'os mais avec le strain qui peut-être n'importe quoi.
global OFYA
set QUI [string toupper $Qui]
regsub " " $QUI "_" QUI
set QUOI [string toupper $Quoi]
if {[info exists OFYA($QUI,$QUOI)]} { return $OFYA($QUI,$QUOI) }
if {[info exists OFYA("EstCharge")]} {
if {[info exists OFYA($QUI,TAXID)]} {
set LaReponse {}
foreach TaxId $OFYA($QUI,TAXID) {
if {[info exists OFYA($TaxId,$QUOI)]} { lappend LaReponse $OFYA($TaxId,$QUOI) }
}
return $LaReponse
}
return ""
}
set OFYA("EstCharge") 1
# set Rep "/home/nevers/StageJuin/Proteomes"
set Rep "/home/nevers/StageJuin/Proteomes"
set OFYA(REP,) $Rep
foreach Fichier [lsort [glob -nocomplain "$Rep/*.tfa"]] {
set Queue [file tail $Fichier]
#if {[regexp {^[0-9]} $Queue]} { continue }
set OsDuFichier ""
set TaxIdDuFichier ""
regsub {\.tfa$} $Queue "" FullName
set FullName [string trim $FullName "_-"]
set G ""
set E ""
set T ""
set S ""
if {[regexp {([0-9]+)_([A-Z][a-z]+)_([a-z\-\.]+)(_(.*)|$)} $FullName Match T G E X S]} {
set TaxIdDuFichier $T
set OsDuFichier "${G}_$E"
set FullOs $OsDuFichier
set Strain $S
if {$Strain!=""} { append FullOs "_$Strain" }
}
if {[info exists DejaVu($TaxIdDuFichier)]} { FaireLire "DejaVu $TaxIdDuFichier" }
set DejaVu($TaxIdDuFichier) 1
set OsFromTax [Tax $TaxIdDuFichier]
regsub " " $OsFromTax "_" OsFromTax
set AfficheOsFromTax "" ; if {$OsFromTax!="$OsDuFichier"} { set AfficheOsFromTax $OsFromTax }
set TaxId $TaxIdDuFichier
set Os $OsDuFichier
regsub "_" $Os " " $Os
set OFYA($TaxId,TAXID) $TaxId
set OFYA($TaxId,FULLNAME) $FullName
set OFYA($TaxId,FILENAME) $Fichier
set OFYA($TaxId,OS) $Os
set OFYA($TaxId,FULLOS) $FullOs
set OFYA($TaxId,STRAIN) $Strain
set OFYA($TaxId,OSFROMTAX) [Tax $TaxId]
set FULLNAME [string toupper $FullName]
set FULLOS [string toupper $FullOs]
set OS [string toupper $Os]
set STRAIN [string toupper $Strain]
set OFYA($FULLNAME,TAXID) $TaxId
set OFYA($FULLOS,TAXID) $TaxId
lappend OFYA($OS,TAXID) $TaxId
lappend OFYA($STRAIN,TAXID) $TaxId
lappend OFYA(LISTOF,TAXID) $TaxId
lappend OFYA(LISTOF,FULLNAME) $FullName
lappend OFYA(LISTOF,FULLOS) $FullOs
lappend OFYA(LISTOF,STRAIN) $Strain
lappend OFYA(LISTOF,FILENAME) $Fichier
}
set OFYA(LISTOF,FULLOS) [lsort -unique $OFYA(LISTOF,FULLOS)]
set OFYA(LISTOF,FULLNAME) [lsort -unique $OFYA(LISTOF,FULLNAME)]
set OFYA(LISTOF,FILENAME) [lsort -unique $OFYA(LISTOF,FILENAME)]
set OFYA(LISTOF,STRAIN) [lsort -unique $OFYA(LISTOF,STRAIN)]
foreach FullOS $OFYA(LISTOF,FULLOS) {
lassign [split $FullOS "_"] G E
set OS "$G $E"
lappend OFYA(LISTOF,OS) $OS
}
return [OrganismFromYannis $Qui $Quoi]
}
proc FromOrthoInspector {{Qui ""} {Quoi ""}} {
#rR Lit les fasta de OrthoInspector
#rR
global FromOrthoInspector
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists FromOrthoInspector($Qui,$Quoi)]} { return $FromOrthoInspector($Qui,$Quoi) }
if {[info exists FromOrthoInspector("EstCharge")]} {
if {[info exists FromOrthoInspector($Qui,ID)]} {
set ID [string toupper $FromOrthoInspector($Qui,ID)]
if {[info exists FromOrthoInspector($ID,$Quoi)]} { return $FromOrthoInspector($ID,$Quoi) }
}
if {[info exists FromOrthoInspector($Qui,TAXID)]} {
set TID $FromOrthoInspector($Qui,TAXID)
if {[info exists FromOrthoInspector($TID,$Quoi)]} { return $FromOrthoInspector($TID,$Quoi) }
}
return ""
}
set FromOrthoInspector("EstCharge") 1
set OnGarde 0
set Rep [OrganismFromOrthoInspector Rep]
set FromOrthoInspector(REP,) $Rep
set LesTaxId [OrganismFromOrthoInspector ListOf TaxId]
set Testons 0 ;#rR pour test ********
if {$Testons} { set LesTaxId [list 9606 9823 764100 4577 6182 7668] }
set FromOrthoInspector(LISTOF,TAXID) [join $LesTaxId "\n"]
foreach TaxId $LesTaxId {
set OsDuFichier [OrganismFromOrthoInspector $TaxId FullOs]
set OsCourtDuFichier [OrganismFromOrthoInspector $TaxId Os]
lappend FromOrthoInspector(LISTOF,FULLOS) $OsDuFichier
set FromOrthoInspector($TaxId,FULLOS) $OsDuFichier
set Fichier [OrganismFromOrthoInspector $TaxId Filename]
set Queue [file tail $Fichier]
set LeTFACourant {}
set LesLignes [LesLignesDuFichier $Fichier]
lappend LesLignes ">CESTFINIPOURCEFICHIER"
set OsDansFichier ""
set MaxiPourTestons 100 ;#rR 100 ou -1 pour tout
if {[info exists Courant]} { unset Courant }
foreach Ligne $LesLignes {
if {$Testons && [incr MaxiPourTestons -1]==0} { break }
regsub -all " +" $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
#rR dans sequence
if { ! [regexp "^>" $Ligne]} {
if {[regexp -nocase {[^A-Z]} $Ligne]} {
if {[string index $Ligne end]=="*"} { set Ligne [string range $Ligne 0 end-1] }
if {[regexp -nocase {[^A-Z\*]} $Ligne Match]} {
#rR la, il y a meme autre chose
lappend FromOrthoInspector(LISTOF,BAD) "$Queue $Courant $Ligne"
FaireLire "Dans $Queue $Courant \n$Ligne"
set OnGarde 0
continue
}
if {[regexp -nocase {\*} $Ligne Match]} {
#FaireLire "Dans $Queue $Courant \n$Ligne"
lappend FromOrthoInspector(LISTOF,OSWHITHSTAR) $Queue
lappend FromOrthoInspector($TaxId,STAR) $Courant
set OnGarde 0
continue
}
}
if {$Ligne!=""} {
set OnGarde 1
lappend LeTFACourant $Ligne
}
continue
}
#rR on a un chevron
#rR on traite d'abord le précédent
if {[info exists Courant]} {
if {$OnGarde} {
set ID [string toupper $Id]
set COURANT [string toupper $Courant]
set FromOrthoInspector($COURANT,TFA) [join $LeTFACourant "\n"]
set FromOrthoInspector($ID,ID) $Id
set FromOrthoInspector($ID,AC) $Ac
lappend FromOrthoInspector(LISTOF,IDS) $Id
lappend FromOrthoInspector(LISTOF,ACS) $Ac
lappend FromOrthoInspector($TaxIdDuCourant,IDS) $Id
lappend FromOrthoInspector($TaxIdDuCourant,ACS) $Ac
set FromOrthoInspector($ID,TAXID) $TaxIdDuCourant
}
}
if {$Ligne==">CESTFINIPOURCEFICHIER"} { break }
#rR on traite l'entête
if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} {
FaireLire "pas bon $Ligne"
lappend LeNew $Ligne
continue
}
set TexteBanque ""
if {[regexp {\|} $Ligne]} {
regexp {^>([^ ]+) (.+)} $Ligne Match AI D
set Banque ""
set Ac ""
set Id ""
lassign [split $AI "|"] Banque Ac Id
if {$Ac==""} { set Ac $AI }
if {$Id==""} { set Id $Ac }
regsub {OS=.*} $D "" D
regsub {GN=.*} $D "" D
regsub -all ";" $D " " D
set D [string trim $D " _,"]
if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
set W $Id
set Id $Ac
set Ac $W
}
if {$Banque!=""} { set TexteBanque " BANK=$Banque" }
} else {
regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac D
regsub {OS=.*} $D "" D
regsub {GN=.*} $D "" D
regsub -all ";" $D " " D
set D [string trim $D " _,"]
if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
set W $Id
set Id $Ac
set Ac $W
}
#rR Traitement spécial pour lui ....................... il y a tr ou gn à la fin des Id ou Ac
if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Id "" Id }
if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Ac "" Ac }
}
set Gn ""
regexp {GN=([^ ]+)} $Ligne Match Gn
set TextGn ""
if {$Gn!=""} { set TextGn " GN=$Gn" }
regsub { (GN|PE|SV)=.*} $Ligne "" LigneSansGN
set FullOs "Unknown unknown"
set OsDansEntete ""
if {[regexp { OS=(.+)} $LigneSansGN Match FullOs]} {
regsub -all " " $FullOs "_" FullOs
regsub -all "/" $FullOs "and" FullOs
set OsDansEntete $FullOs
}
lassign [split $FullOs "_"] G E
set Entete ">$Id $Ac $G $E $D $TextGn OS=$OsDuFichier TAXID=$TaxId$TexteBanque"
set LeTFACourant [list $Entete]
if {$OsDansEntete==""} { set OsDansFichier $FullOs }
if {$OsDansEntete!=$OsDuFichier && $OsDansEntete!=$OsCourtDuFichier} {
set Message "Dans $Queue\n$OsDansEntete differe de \n$OsDuFichier\n\n$OsDansEntete differe de \n$OsCourtDuFichier"
if {0 && ! [info exists MessageLu($Message)]} {
FaireLire "$Message"
set MessageLu($Message) 1
}
}
set Courant $Id
set COURANT [string toupper $Courant]
set TaxIdDuCourant $TaxId
set ID [string toupper $Id]
set AC [string toupper $Ac]
if {$ID!=$AC} { set FromOrthoInspector($AC,ID) $ID }
set FromOrthoInspector($ID,FULLOS) $FullOs
set FULLOS [string toupper $FullOs]
set FromOrthoInspector($FULLOS,TAXID) $TaxId
}
set FromOrthoInspector([string toupper $OsDuFichier],TAXID) $TaxId
}
set FromOrthoInspector(LISTOF,STAR) {}
set FromOrthoInspector(LISTOF,COUNTSTAR) {}
foreach TaxId $LesTaxId {
if { ! [info exists FromOrthoInspector($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue }
set FullOs $FromOrthoInspector($TaxId,FULLOS)
lappend FromOrthoInspector(LISTOF,TAXIDOS) "${TaxId}_$FullOs"
set nOK [llength $FromOrthoInspector($TaxId,IDS)]
lappend FromOrthoInspector(LISTOF,COUNT) "$nOK $TaxId $FullOs"
if {[info exists FromOrthoInspector($TaxId,STAR)]} {
set nKO [llength $FromOrthoInspector($TaxId,STAR)]
lappend FromOrthoInspector(LISTOF,COUNTSTAR) "$nKO $nOK $TaxId $FullOs"
}
}
set FromOrthoInspector(LISTOF,TAXIDOS) [join $FromOrthoInspector(LISTOF,TAXIDOS) "\n"]
set FromOrthoInspector(LISTOF,FULLOS) [join $FromOrthoInspector(LISTOF,FULLOS) "\n"]
set FromOrthoInspector(LISTOF,COUNT) [join $FromOrthoInspector(LISTOF,COUNT) "\n"]
set FromOrthoInspector(LISTOF,STAR) [join $FromOrthoInspector(LISTOF,STAR) "\n"]
set FromOrthoInspector(LISTOF,COUNTSTAR) [join $FromOrthoInspector(LISTOF,COUNTSTAR) "\n"]
return [FromOrthoInspector $Qui $Quoi]
}
proc FromYannis {{Qui ""} {Quoi ""}} {
#rR Lit les fasta de Yannis
#rR en utilisant OrganismFromYannis qui lit tous les ficheirs d'un repertoire
global FromYannis
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists FromYannis($Qui,$Quoi)]} { return $FromYannis($Qui,$Quoi) }
if {[info exists FromYannis("EstCharge")]} {
if {[info exists FromYannis($Qui,ID)]} {
set ID [string toupper $FromYannis($Qui,ID)]
if {[info exists FromYannis($ID,$Quoi)]} { return $FromYannis($ID,$Quoi) }
}
if {[info exists FromYannis($Qui,TAXID)]} {
set TID $FromYannis($Qui,TAXID)
if {[info exists FromYannis($TID,$Quoi)]} { return $FromYannis($TID,$Quoi) }
}
return ""
}
set FromYannis("EstCharge") 1
set OnGarde 0
set Rep [OrganismFromYannis Rep]
set FromYannis(REP,) $Rep
set LesTaxId [OrganismFromYannis ListOf TaxId]
set Testons 0 ;#rR pour test ********
if {$Testons} { set LesTaxId [list 9606 9823 764100 4577 6182 7668] }
set FromYannis(LISTOF,TAXID) [join $LesTaxId "\n"]
foreach TaxId $LesTaxId {
set OsDuFichier [OrganismFromYannis $TaxId FullOs]
set OsCourtDuFichier [OrganismFromYannis $TaxId Os]
lappend FromYannis(LISTOF,FULLOS) $OsDuFichier
set FromYannis($TaxId,FULLOS) $OsDuFichier
set Fichier [OrganismFromYannis $TaxId Filename]
set Queue [file tail $Fichier]
set LeTFACourant {}
set LesLignes [LesLignesDuFichier $Fichier]
lappend LesLignes ">CESTFINIPOURCEFICHIER"
set OsDansFichier ""
set MaxiPourTestons 100 ;#rR 100 ou -1 pour tout
if {[info exists Courant]} { unset Courant }
foreach Ligne $LesLignes {
if {$Testons && [incr MaxiPourTestons -1]==0} { break }
regsub -all " +" $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
#rR dans sequence
if { ! [regexp "^>" $Ligne]} {
if {[regexp -nocase {[^A-Z]} $Ligne]} {
if {[string index $Ligne end]=="*"} { set Ligne [string range $Ligne 0 end-1] }
if {[regexp -nocase {[^A-Z\*]} $Ligne Match]} {
#rR la, il y a meme autre chose
lappend FromYannis(LISTOF,BAD) "$Queue $Courant $Ligne"
FaireLire "Dans $Queue $Courant \n$Ligne"
set OnGarde 0
continue
}
if {[regexp -nocase {\*} $Ligne Match]} {
#FaireLire "Dans $Queue $Courant \n$Ligne"
lappend FromYannis(LISTOF,OSWHITHSTAR) $Queue
lappend FromYannis($TaxId,STAR) $Courant
set OnGarde 0
continue
}
}
if {$Ligne!=""} {
set OnGarde 1
lappend LeTFACourant $Ligne
}
continue
}
#rR on a un chevron
#rR on traite d'abord le précédent
if {[info exists Courant]} {
if {$OnGarde} {
set ID [string toupper $Id]
set COURANT [string toupper $Courant]
set FromYannis($COURANT,TFA) [join $LeTFACourant "\n"]
set MemoTaxId $MemoTaxIdDuCourant($COURANT)
set FromYannis($ID,ID) $Id
set FromYannis($ID,AC) $Ac
lappend FromYannis(LISTOF,IDS) $Id
lappend FromYannis(LISTOF,ACS) $Ac
lappend FromYannis($MemoTaxId,IDS) $Id
lappend FromYannis($MemoTaxId,ACS) $Ac
set FromYannis($ID,TAXID) $MemoTaxId
}
}
if {$Ligne==">CESTFINIPOURCEFICHIER"} { break }
#rR on traite l'entête
if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} {
FaireLire "pas bon $Ligne"
lappend LeNew $Ligne
continue
}
set TexteBanque ""
if {[regexp {\|} $Ligne]} {
regexp {^>([^ ]+) (.+)} $Ligne Match AI D
set Banque ""
set Ac ""
set Id ""
lassign [split $AI "|"] Banque Ac Id
if {$Ac==""} { set Ac $AI }
if {$Id==""} { set Id $Ac }
regsub {OS=.*} $D "" D
regsub {GN=.*} $D "" D
regsub -all ";" $D " " D
set D [string trim $D " _,"]
if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
set W $Id
set Id $Ac
set Ac $W
}
if {$Banque!=""} { set TexteBanque " BANK=$Banque" }
} else {
regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac D
regsub {OS=.*} $D "" D
regsub {GN=.*} $D "" D
regsub -all ";" $D " " D
set D [string trim $D " _,"]
if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
set W $Id
set Id $Ac
set Ac $W
}
#rR Traitement spécial pour lui ....................... il y a tr ou gn à la fin des Id ou Ac
if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Id "" Id }
if {$TaxId==7668} { regsub {(tr|sp|gn)$} $Ac "" Ac }
}
set Gn ""
regexp {GN=([^ ]+)} $Ligne Match Gn
set TextGn ""
if {$Gn!=""} { set TextGn " GN=$Gn" }
regsub { (GN|PE|SV)=.*} $Ligne "" LigneSansGN
set FullOs "Unknown unknown"
set OsDansEntete ""
if {[regexp { OS=(.+)} $LigneSansGN Match FullOs]} {
regsub -all " " $FullOs "_" FullOs
regsub -all "/" $FullOs "and" FullOs
set OsDansEntete $FullOs
}
lassign [split $FullOs "_"] G E
set Entete ">$Id $Ac $G $E $D $TextGn OS=$OsDuFichier TAXID=$TaxId$TexteBanque"
set LeTFACourant [list $Entete]
if {$OsDansEntete==""} { set OsDansFichier $FullOs }
if {$OsDansEntete!=$OsDuFichier && $OsDansEntete!=$OsCourtDuFichier} {
set Message "Dans $Queue\n$OsDansEntete differe de \n$OsDuFichier\n\n$OsDansEntete differe de \n$OsCourtDuFichier"
if {0 && ! [info exists MessageLu($Message)]} {
FaireLire "$Message"
set MessageLu($Message) 1
}
}
set Courant $Id
set COURANT [string toupper $Courant]
set MemoTaxIdDuCourant($COURANT) $TaxId
set ID [string toupper $Id]
set AC [string toupper $Ac]
if {$ID!=$AC} { set FromYannis($AC,ID) $ID }
set FromYannis($ID,FULLOS) $FullOs
set FULLOS [string toupper $FullOs]
set FromYannis($FULLOS,TAXID) $TaxId
}
set FromYannis([string toupper $OsDuFichier],TAXID) $TaxId
}
set FromYannis(LISTOF,STAR) {}
set FromYannis(LISTOF,COUNTSTAR) {}
foreach TaxId $LesTaxId {
if { ! [info exists FromYannis($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue }
set FullOs $FromYannis($TaxId,FULLOS)
lappend FromYannis(LISTOF,TAXIDOS) "${TaxId}_$FullOs"
set nOK [llength $FromYannis($TaxId,IDS)]
lappend FromYannis(LISTOF,COUNT) "$nOK $TaxId $FullOs"
if {[info exists FromYannis($TaxId,STAR)]} {
set nKO [llength $FromYannis($TaxId,STAR)]
lappend FromYannis(LISTOF,COUNTSTAR) "$nKO $nOK $TaxId $FullOs"
}
}
set FromYannis(LISTOF,TAXIDOS) [join $FromYannis(LISTOF,TAXIDOS) "\n"]
set FromYannis(LISTOF,FULLOS) [join $FromYannis(LISTOF,FULLOS) "\n"]
set FromYannis(LISTOF,COUNT) [join $FromYannis(LISTOF,COUNT) "\n"]
set FromYannis(LISTOF,STAR) [join $FromYannis(LISTOF,STAR) "\n"]
set FromYannis(LISTOF,COUNTSTAR) [join $FromYannis(LISTOF,COUNTSTAR) "\n"]
return [FromYannis $Qui $Quoi]
}
proc RajouteCrEnFinDeFasta {} {
set Rep "/biolo/orthoinspector/DataOrthoinspector/Orthoinspector_v2/eukaryota/all"
foreach Fichier [lsort [glob -nocomplain "$Rep/*.fasta"]] {
set Queue [file tail $Fichier]
set f [open $Fichier "a+"]
set Texte [read $f]
if {[string index $Texte end]=="\n"} { close $f; continue }
puts $f ""
Espionne $Queue
close $f
}
}
proc CreeUneBanqueBlastPAL {{LesOsChoisis ""} {Banque ""} {Dir ""}} {
#rR on suppose que les .phr existent déjà.
#rR LesOsChoisis sont une liste de TaxId qui figurent en fin du nom des fichiers .phr
set LesOSTaxId {}
set LesOS {}
set LesTaxId {}
if {$Banque==""} { set Banque "BlastDatabase_[Date]" }
if {$Dir!=""} { set Dir "[RepertoireDuGenome]/banques" }
NousAllonsAuBoulot $Dir
foreach Fichier [lsort [glob -nocomplain "*.phr"]] {
regsub ".phr$" $Fichier "" OSTaxId
if { ! [regexp {([A-Z][a-z]+_[a-z\.]+)_([0-9]+)$} $OSTaxId Match OS TaxId]} { continue }
lappend LesOSTaxId $OSTaxId
lappend LesOS $OS
lappend LesTaxId $TaxId
set OSTaxIdDu($TaxId) $OSTaxId
set OSTaxIdDu($OSTaxId) $OSTaxId
}
if {$LesOsChoisis==""} { set LesOsChoisis [OrganismListForCilioCode "TaxId"] }
if {$LesOsChoisis==""} { set LesOsChoisis [split [Affiche $LesOSTaxId "AvecRetour" "Select_the_organisms_and_press_Validate"] "\n"] }
if {$LesOsChoisis==""} { return "" }
set LesFichiersChoisis {}
foreach Choix $LesOsChoisis {
if { ! [info exists OSTaxIdDu($Choix)]} {
set OsName [Tax $Choix]
if {$OsName!=""} {
set iUnder [string first " " $OsName]
Espionne $iUnder
set Debut [string range $OsName 0 [incr iUnder -1]]
Espionne $Debut
set PhrTrouves [glob -nocomplain "$Debut*.phr"]
if {$PhrTrouves!=""} {
set PhrRemplace ""
if {[llength $PhrTrouves]==1} {
if {[OuiOuNon "I couldn't find $Choix $OsName\n Can I use \n$PhrTrouves\n"]} {
set PhrRemplace $PhrTrouves
}
} else {
if {[OuiOuNon "I couldn't find $Choix $OsName\n Ok to coose within\n$PhrTrouves\n"]} {
set PhrRemplace [ChoixParmi $PhrTrouves]
}
}
if {$PhrRemplace!=""} {
regsub ".phr$" $PhrRemplace "" Secours
lappend LesFichiersChoisis $Secours
continue
}
}
}
Espionne "I can not find $Choix I'll skip it. Sorry"
continue
}
lappend LesFichiersChoisis $OSTaxIdDu($Choix)
}
if {$LesFichiersChoisis==""} { return "" }
set LeTextePal {}
lappend LeTextePal "#"
lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastPAL"
lappend LeTextePal "#"
lappend LeTextePal "#"
lappend LeTextePal "TITLE $Banque"
lappend LeTextePal "#"
set LePal $LesFichiersChoisis
set LePal [lsort -unique $LePal]
set Pal [join $LePal " "]
lappend LeTextePal "DBLIST $Pal"
lappend LeTextePal "#"
set BanqueCreee [SauveLesLignes $LeTextePal dans "$Banque.pal"]
OnRevientDuBoulot
return "$Dir/$BanqueCreee"
}
proc CreeUneBanqueBlastAvecYannis {{LesOsChoisis ""} {Banque ""} {Separate ""}} {
#rR a parfaire !!!!!!!!!!!!!!!!!! pour aller chercher les banques dans /biolo/orthoinspector/.../proteomes ou ils existent déjà
if {$Separate==""} { set Separate "Separate" }
set Separate [regexp -nocase "Separ" $Separate]
set Dir ""
if {$Banque==""} { set Banque "Proteome" }
if {[regexp "/" $Banque]} {
set Dir [file dirname $Banque]
set Banque [file tail $Banque]
}
if {$Dir==""} { set Dir "[RepertoireDuGenome]/banques" }
file mkdir $Dir
if {$LesOsChoisis==""} {
set LesOS [FromYannis ListOf TaxIdOs]
set Choisis [Affiche $LesOS "AvecRetour" "Select_the_organisms_and_press_Validate"]
set LesOsChoisis [split $Choisis "\n"]
}
if {[string equal -nocase "All" $LesOsChoisis]} {
set LesOsChoisis [split [FromYannis ListOf TaxIdOs] "\n"]
}
NousAllonsAuBoulot $Dir
set LePal {}
if {$Separate} {
lappend LeTextePal "#"
lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastAvecYannis"
lappend LeTextePal "#"
lappend LeTextePal "#"
lappend LeTextePal "TITLE $Banque"
lappend LeTextePal "#"
}
set LeGrosTfa {}
foreach OS $LesOsChoisis {
set TaxId ""; set G ""; set E ""
lassign [split $OS "_"] TaxId G E
if {$TaxId=="" || $G=="" || $E==""} { FaireLire "$OS is wrong I'll skip" ; continue }
set GET "${G}_${E}_${TaxId}"
set i 0
set LePetitTfa {}
foreach ID [FromYannis $TaxId IDs] {
set ID [string toupper $ID]
if {[info exists DejaVu($ID)]} { FaireLire "Deja vu $ID"; continue }
set TFA [FromYannis $ID TFA]
if {$TFA==""} { continue }
if {$Separate} {
lappend LePetitTfa $TFA
lappend LePal $GET
} else {
lappend LeGrosTfa $TFA
}
incr i
}
AppendAuFichier ${Banque}_TaillesDesOs.txt "$i $GET"
if {$Separate && ! [file exists $GET.phr]} {
SauveLesLignes $LePetitTfa dans $GET
exec formatdb -i $GET -p T
}
}
set LePal [lsort -unique $LePal]
if {$Separate} {
set Pal [join $LePal " "]
lappend LeTextePal "DBLIST $Pal"
lappend LeTextePal "#"
SauveLesLignes $LeTextePal dans "$Banque.pal"
} else {
while {[glob -nocomplain $Banque]!={} || [glob -nocomplain $Banque.*]!={}} {
if {[OuiOuNon "Attention. Some files with the same name already exist.\nPlease verify and remove them if necessary\nDo I overwrite"]} {
break
}
if {[OuiOuNon "Do I stop creating the BlastDatabase"]} { return "" }
}
SauveLesLignes $LeGrosTfa dans $Banque
exec formatdb -i $Banque -p T
}
OnRevientDuBoulot
return "$Dir/$Banque"
}
proc CreeUneBanqueBlastAvecOrthoInspector {{LesOsChoisis ""} {Banque ""} {Separate ""}} {
#rR a parfaire !!!!!!!!!!!!!!!!!! pour aller chercher les banques dans /biolo/orthoinspector/.../proteomes ou ils existent déjà
if {$Separate==""} { set Separate "Separate" }
set Separate [regexp -nocase "Separ" $Separate]
set Dir ""
if {$Banque==""} { set Banque "FromOI" }
if {[regexp "/" $Banque]} {
set Dir [file dirname $Banque]
set Banque [file tail $Banque]
}
if {$Dir==""} { set Dir "[RepertoireDuGenome]/banques" }
file mkdir $Dir
if {$LesOsChoisis==""} {
set LesOS [FromOrthoInspector ListOf TaxIdOs]
set Choisis [Affiche $LesOS "AvecRetour" "Select_the_organisms_and_press_Validate"]
set LesOsChoisis [split $Choisis "\n"]
}
if {[string equal -nocase "All" $LesOsChoisis]} {
set LesOsChoisis [split [FromOrthoInspector ListOf TaxIdOs] "\n"]
}
NousAllonsAuBoulot $Dir
set LePal {}
if {$Separate} {
lappend LeTextePal "#"
lappend LeTextePal "# Alias file created by Gscope CreeUneBanqueBlastAvecOrthoInspector"
lappend LeTextePal "#"
lappend LeTextePal "#"
lappend LeTextePal "TITLE $Banque"
lappend LeTextePal "#"
}
set LeGrosTfa {}
foreach OS $LesOsChoisis {
set TaxId ""; set G ""; set E ""
lassign [split $OS "_"] TaxId G E
if {$TaxId=="" || $G=="" || $E==""} { FaireLire "$OS is wrong I'll skip" ; continue }
set GET "${G}_${E}_${TaxId}"
set i 0
set LePetitTfa {}
foreach ID [FromOrthoInspector $TaxId IDs] {
set ID [string toupper $ID]
if {[info exists DejaVu($ID)]} { FaireLire "Deja vu $ID"; continue }
set TFA [FromOrthoInspector $ID TFA]
if {$TFA==""} { continue }
if {$Separate} {
lappend LePetitTfa $TFA
lappend LePal $GET
} else {
lappend LeGrosTfa $TFA
}
incr i
}
AppendAuFichier ${Banque}_TaillesDesOs.txt "$i $GET"
if {$Separate && ! [file exists $GET.phr]} {
SauveLesLignes $LePetitTfa dans $GET
exec formatdb -i $GET -p T
}
}
set LePal [lsort -unique $LePal]
if {$Separate} {
set Pal [join $LePal " "]
lappend LeTextePal "DBLIST $Pal"
lappend LeTextePal "#"
SauveLesLignes $LeTextePal dans "$Banque.pal"
} else {
while {[glob -nocomplain $Banque]!={} || [glob -nocomplain $Banque.*]!={}} {
if {[OuiOuNon "Attention. Some files with the same name already exist.\nPlease verify and remove them if necessary\nDo I overwrite"]} {
break
}
if {[OuiOuNon "Do I stop creating the BlastDatabase"]} { return "" }
}
SauveLesLignes $LeGrosTfa dans $Banque
exec formatdb -i $Banque -p T
}
OnRevientDuBoulot
return "$Dir/$Banque"
}
proc CilioCartaDb {{Qui ""} {Quoi ""} {Value ""} {GetWhat ""}} {
CanalSqlCilioCarta
# set R [SqlExec "select name from sqlite_master" $Quoi]
# set R [SqlExec "select * from prot where genename is not null limit 3" $Quoi]
if {[regexp -nocase "ListOf" $Qui] && [regexp -nocase "Table" $Quoi]} {
return [SqlExec "SELECT name FROM sqlite_master" "GetList"]
}
if {[regexp -nocase "Sql" $Qui] } {
return [SqlExec "SELECT sql FROM sqlite_master WHERE name='$Quoi'" "GetFirstValue"]
}
if {[regexp "Columns" $Qui]} {
set S [SqlExec "SELECT sql FROM sqlite_master WHERE name='$Quoi'" "GetFirstValue"]
set LesMots [split [string trim [join [lrange [split $S " "] 3 end] " "] "()"] ","]
set LeR {}
set LesC {}
foreach Mot $LesMots {
set Mot [string trim $Mot]
regsub " " $Mot "\t" Mot
lassign [split $Mot "\t"] N T
regsub -all {\"} $N "" N
lappend LeR [format "%-25s\t%s" $N $T]
lappend LesC $N
}
if {[regexp "ColumnsWith" $Qui]} { return $LeR }
return $LesC
}
return [SqlExec "select * from $Qui where $Quoi like '$Value'" $GetWhat]
}
proc FastaForBlast {{Qui ""} {Quoi ""} {FastaFile ""} {NewFastaFile ""}} {
global FastaForBlast
set RemovePipeFromHeader [OuiOuNon "Do I replace >sp|ac|id with >ID AC" 0 ]
#rR on lit le fichier fasta fourni par Uniprot et si RemeovePipeFromHeader on modifie sp|ac|id en SPT:ID AC
#rR on rajoute aussi OX=9606 en fin d'entete (attentio avant j'avais OX: ... !)
#rR les statistiques peuvent se faire apres création du nouveau fasta avec StatFromFasta ci-dessous
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {$Qui=="-"} { set Qui "" }
if {$Quoi=="-"} { set Quoi "" }
if {$FastaFile!=""} {
if {[info exists FastaForBlast(FASTAFILE,)]} {
if {$FastaForBlast(FASTAFILE,)!=$FastaFile} {
unset FastaForBlast
}
}
set FastaFileToSet $FastaFile
set NewFastaFileToSet $NewFastaFile
}
if {[info exists FastaForBlast($Qui,$Quoi)]} { return $FastaForBlast($Qui,$Quoi) }
if {[info exists FastaForBlast("EstCharge")]} {
if {[info exists FastaForBlast($Qui,ID)]} {
set ID [string toupper $FastaForBlast($Qui,ID)]
if {[info exists FastaForBlast($ID,$Quoi)]} { return $FastaForBlast($ID,$Quoi) }
}
if {[info exists FastaForBlast($Qui,TAXID)]} {
set TID $FastaForBlast($Qui,TAXID)
if {[info exists FastaForBlast($TID,$Quoi)]} { return $FastaForBlast($TID,$Quoi) }
}
return ""
}
if { ! [info exists FastaFileToSet]} {
FaireLire "Please give the name of the FastaFile"
return ""
}
set FastaForBlast(FASTAFILE,) $FastaFileToSet
set FastaForBlast(NEWFASTAFILE,) $NewFastaFileToSet
set FastaForBlast("EstCharge") 1
set FastaFile $FastaForBlast(FASTAFILE,)
set Queue [file tail $FastaFile]
set OnGarde 1
set LeTFAACreer {}
set FlushSize 10000
set iFlush 0
set DejaStocke 0
if {$FastaForBlast(NEWFASTAFILE,)==""} {
set CreateNew 0
} else {
set CreateNew 1
if {[file exists $FastaForBlast(NEWFASTAFILE,)]} {
if {[OuiOuNon "$FastaForBlast(NEWFASTAFILE,)\n already exists. Do I overwrite"]} {
file delete $FastaForBlast(NEWFASTAFILE,)
} else {
if { ! [OuiOuNon "$FastaForBlast(NEWFASTAFILE,)\n already exists. Do I append"]} {
return ""
}
}
}
}
set MaxiPourTestons -10000 ;#rR 100 pour limité, -100 pour illimité
set F [open $FastaForBlast(FASTAFILE,) "r"]
while {1} {
set OnBreak [expr [gets $F Ligne] < 0 ]
if { ! $OnBreak } {
regsub -all " +" $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
#rR dans sequence
if { ! [regexp "^>" $Ligne]} {
lappend LeTFAACreer $Ligne
continue
}
}
#rR on a un chevron
#rR on traite d'abord le précédent
if {[info exists Courant]} {
if {$OnGarde} {
if {[incr MaxiPourTestons -1]==0} { set OnBreak 1 }
set ID [string toupper $Id]
set COURANT [string toupper $Courant]
lappend FastaForBlast(LISTOF,IDS) $Id
lappend FastaForBlast(LISTOF,ACS) $Ac
lappend FastaForBlast($MemoTaxId,IDS) $Id
lappend FastaForBlast($MemoTaxId,ACS) $Ac
if { ! $CreateNew} {
#set FastaForBlast($COURANT,TFA) [join $LeTFACourant "\n"]
set FastaForBlast($ID,ID) $Id
set FastaForBlast($ID,AC) $Ac
set FastaForBlast($ID,TAXID) $MemoTaxId
}
incr iFlush
if {$CreateNew && ($iFlush>=$FlushSize || ($iFlush>0 && $OnBreak))} {
AppendAuFichier $FastaForBlast(NEWFASTAFILE,) [join $LeTFAACreer "\n"]
incr DejaStocke $iFlush
Espionne "$DejaStocke sequences already done."
set LeTFAACreer {}
set iFlush 0
}
}
}
if {$OnBreak} { break }
#rR on traite l'entête
if { ! [regexp {^>([^ ]+) (.+)} $Ligne Match AI D]} {
FaireLire "pas bon $Ligne"
lappend LeNew $Ligne
continue
}
set TexteTaxId ""
if {[regexp {\|} $Ligne]} {
#rR on espere >Banque|Ac|Id Definition... (attention à l'ordre)
set ResteDeLaLigne ""
regexp {^>([^ ]+) (.+)} $Ligne Match BAI ResteDeLaLigne
set Banque ""
set Ac ""
set Id ""
lassign [split $BAI "|"] Banque Ac Id
if {$Ac==""} { set Ac $BAI }
if {$Id==""} { set Id $Ac }
if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
set W $Id
set Id $Ac
set Ac $W
}
} else {
#rR on espere >Banque:Id Ac Definition... (Attention à l'ordre Id avant Ac)
set Banque ""
set Id ""
set Ac ""
set ResteDeLaLigne ""
regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac ResteDeLaLigne
if {[regexp {([^\:]+)\:(.+)} $Id Match B I]} {
set Banque $B
set Id $I
}
if {$Ac==""} { set Ac $Id }
if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
set W $Id
set Id $Ac
set Ac $W
}
}
set TexteBanque ""
# on laisse comme c'est if {[string equal -nocase "sp" $Banque]} { set Banque "SW" }
# on laisse comme c'est if {[string equal -nocase "tr" $Banque]} { set Banque "TR" }
#rR supprimé 20160708 *************************************************** if {$Banque!=""} { set TexteBanque "$Banque:" }
set Gn ""
regexp {GN=([^ ]+)} $Ligne Match Gn
set TextGn ""
if {$Gn!=""} { set TextGn " GN=$Gn" }
set FullOs "Unknown unknown"
if {[regexp { OS=(.+)} $Ligne Match FullOsWithJunk]} {
regsub {[A-Z][A-Z]=.*} $FullOsWithJunk "" FullOs
set FullOs [string trim $FullOs]
}
set TexteTaxId ""
set TaxId [TaxParQdsMemo $FullOs]
if {$TaxId!=""} {
lappend LesTaxId $TaxId
set TexteTaxId " OX=$TaxId"
set FastaForBlast($TaxId,FULLOS) $FullOs
}
if {$RemovePipeFromHeader} {
set Entete ">$TexteBanque$Id $Ac $ResteDeLaLigne$TexteTaxId"
} else {
set Entete "$Ligne$TexteTaxId"
}
lappend LeTFAACreer $Entete
set Courant $Id
set COURANT [string toupper $Courant]
set MemoTaxId $TaxId
set ID [string toupper $Id]
set AC [string toupper $Ac]
if { ! $CreateNew} {
if {$ID!=$AC} { set FastaForBlast($AC,ID) $ID }
set FastaForBlast($ID,FULLOS) $FullOs
}
set FULLOS [string toupper $FullOs]
set FastaForBlast($FULLOS,TAXID) $TaxId
}
set LesTaxId [lsort -unique $LesTaxId]
set FastaForBlast(LISTOF,TAXID) $LesTaxId
foreach TaxId $LesTaxId {
if { ! [info exists FastaForBlast($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue }
set FullOs $FastaForBlast($TaxId,FULLOS)
lappend FastaForBlast(LISTOF,FULLOS) "$FullOs"
lappend FastaForBlast(LISTOF,TAXIDOS) "${TaxId}_$FullOs"
set nOK [llength $FastaForBlast($TaxId,IDS)]
lappend FastaForBlast(LISTOF,COUNT) "$nOK $TaxId $FullOs"
}
set FastaForBlast(LISTOF,TAXID) [join $FastaForBlast(LISTOF,TAXID) "\n"]
set FastaForBlast(LISTOF,TAXIDOS) [join $FastaForBlast(LISTOF,TAXIDOS) "\n"]
set FastaForBlast(LISTOF,FULLOS) [join $FastaForBlast(LISTOF,FULLOS) "\n"]
set FastaForBlast(LISTOF,COUNT) [join $FastaForBlast(LISTOF,COUNT) "\n"]
if {$CreateNew} {
set FichierStat "$FastaForBlast(NEWFASTAFILE,).stat"
set FastaForBlast(STAT,FILENAME) [Sauve $FastaForBlast(LISTOF,COUNT) dans $FichierStat]
}
return [FastaForBlast $Qui $Quoi]
}
proc StatFromFasta {{Qui ""} {Quoi ""} {FastaFile ""} {StatFile ""} {ProcessAlsoId ""}} {
global StatFromFasta
set ProcessAlsoId [string equal -nocase $ProcessAlsoId "ProcessAlsoId"]
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {$FastaFile!=""} {
if {[info exists StatFromFasta(FASTAFILE,)]} {
if {$StatFromFasta(FASTAFILE,)!=$FastaFile} {
unset StatFromFasta
}
}
set StatFromFasta(FASTAFILE,) $FastaFile
set StatFromFasta(STAFILE,) $StatFile
}
if { ! [info exists StatFromFasta(FASTAFILE,)]} {
FaireLire "Please give the name of the FastaFile"
return ""
}
if {[info exists StatFromFasta($Qui,$Quoi)]} { return $StatFromFasta($Qui,$Quoi) }
if {[info exists StatFromFasta("EstCharge")]} {
if {[info exists StatFromFasta($Qui,TAXID)]} {
set TID $StatFromFasta($Qui,TAXID)
if {[info exists StatFromFasta($TID,$Quoi)]} { return $StatFromFasta($TID,$Quoi) }
}
return ""
}
set StatFromFasta("EstCharge") 1
set FastaFile $StatFromFasta(FASTAFILE,)
set OnGarde 1
set DejaFaits 0
set MaxiPourTestons -1000 ;#rR 100 pour limité, -100 pour illimité
set F [open $StatFromFasta(FASTAFILE,) "r"]
while {1} {
set OnBreak [expr [gets $F Ligne] < 0 ]
if {$OnBreak } { break }
if { ! [regexp ">" $Ligne]} { continue }
if {[incr MaxiPourTestons -1]==0} { break }
regsub -all " +" $Ligne " " Ligne
set Ligne [string trim $Ligne]
if {[incr DejaFaits]%10000==0} { Espionne "$DejaFaits déjà faits" }
if {[regexp {\|} $Ligne]} {
#rR normalement on a que le cas else si on a fait FastaForBlast
#rR on espere >Banque|Ac|Id Definition... (attention à l'ordre)
set ResteDeLaLigne ""
regexp {^>([^ ]+) (.+)} $Ligne Match BAI ResteDeLaLigne
set Banque ""
set Ac ""
set Id ""
lassign [split $BAI "|"] Banque Ac Id
if {$Ac==""} { set Ac $BAI }
if {$Id==""} { set Id $Ac }
if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
set W $Id
set Id $Ac
set Ac $W
}
} else {
#rR on espere >Banque:Id Ac Definition... (Attention à l'ordre Id avant Ac)
set Banque ""
set Id ""
set Ac ""
set ResteDeLaLigne ""
regexp {^>([^ ]+) ([^ ]+) (.+)} $Ligne Match Id Ac ResteDeLaLigne
if {[regexp {([^\:]+)\:(.+)} $Id Match B I]} {
set Banque $B
set Id $I
}
if {$Ac==""} { set Ac $Id }
if {[regexp "_" $Ac] && ! [regexp "_" $Id]} {
set W $Id
set Id $Ac
set Ac $W
}
}
set FullOs "Unknown unknown"
if {[regexp { OS=(.+)} $Ligne Match FullOsWithJunk]} {
regsub {[A-Z][A-Z]=.*} $FullOsWithJunk "" FullOs
set FullOs [string trim $FullOs]
}
set TaxId [IntegerApres "OX=" dans $Ligne]
if {$TaxId==""} {
set TaxId [IntegerApres "OX:" dans $Ligne]
}
if {$TaxId!=""} {
lappend LesTaxId $TaxId
set StatFromFasta($TaxId,FULLOS) $FullOs
}
set Courant $Id
set COURANT [string toupper $Courant]
set ID [string toupper $Id]
set AC [string toupper $Ac]
if {$ProcessAlsoId} {
if {$ID!=$AC} { set StatFromFasta($AC,ID) $ID }
set StatFromFasta($ID,FULLOS) $FullOs
}
set FULLOS [string toupper $FullOs]
set StatFromFasta($FULLOS,TAXID) $TaxId
set ID [string toupper $Id]
set COURANT [string toupper $Courant]
lappend StatFromFasta(LISTOF,IDS) $Id
lappend StatFromFasta(LISTOF,ACS) $Ac
lappend StatFromFasta($TaxId,IDS) $Id
lappend StatFromFasta($TaxId,ACS) $Ac
if {$ProcessAlsoId} {
set StatFromFasta($ID,ID) $Id
set StatFromFasta($ID,AC) $Ac
set StatFromFasta($ID,TAXID) $TaxId
}
}
set LesTaxId [lsort -unique $LesTaxId]
set StatFromFasta(LISTOF,TAXID) $LesTaxId
foreach TaxId $LesTaxId {
if { ! [info exists StatFromFasta($TaxId,IDS)]} { FaireLire "$TaxId empty" ; continue }
set FullOs $StatFromFasta($TaxId,FULLOS)
lappend StatFromFasta(LISTOF,FULLOS) "$FullOs"
lappend StatFromFasta(LISTOF,TAXIDOS) "${TaxId}_$FullOs"
set nOK [llength $StatFromFasta($TaxId,IDS)]
lappend StatFromFasta(LISTOF,COUNT) "$nOK $TaxId $FullOs"
}
set StatFromFasta(LISTOF,TAXID) [join $StatFromFasta(LISTOF,TAXID) "\n"]
set StatFromFasta(LISTOF,TAXIDOS) [join $StatFromFasta(LISTOF,TAXIDOS) "\n"]
set StatFromFasta(LISTOF,FULLOS) [join $StatFromFasta(LISTOF,FULLOS) "\n"]
set StatFromFasta(LISTOF,COUNT) [join $StatFromFasta(LISTOF,COUNT) "\n"]
if {$StatFile!=""} {
set StatFromFasta(STAT,FILENAME) [Sauve $StatFromFasta(LISTOF,COUNT) dans $StatFile]
}
return [StatFromFasta $Qui $Quoi]
}
proc PdbInfo {{Qui ""} {Quoi ""}} {
global PdbInfo
if {[info exists PdbInfo($Qui,$Quoi)]} { return $PdbInfo($Qui,$Quoi) }
if {[info exists PdbInfo("EstCharge")]} { return "" }
set PdbInfo("EstCharge") 1
set FichierProtnames "./protnames.lst"
foreach Ligne [LesLignesDuFichier $FichierProtnames] {
scan $Ligne "%s" Acc
set PdbInfo($Acc,txt) $Ligne
lappend PdbInfo(listof,acc) $Acc
if {[regexp -nocase {^([0-9a-z]+) [\*\- ]+$} $Ligne Match Acc]} {
set PdbInfo($Acc,def) ""
continue
}
if {[regexp -nocase {^([0-9a-z]+) +\* +\- +\- +} $Ligne Match Acc]} {
regsub {^([0-9a-z]+) +\* +\- +\- +} $Ligne "" Def
set PdbInfo($Acc,def) [string trim $Def]
continue
}
set T ""
set Date ""
set Meth ""
lassign [split $Ligne " "] Acc T Date Meth
if { ! [regexp {^[0-9][0-9]\-[A-Z][a-z][a-z]\-[0-9][0-9]$} $Date]} {
if {[regexp {(X\-ray|NMR) +([0-9\.]+) (.+)$} $Ligne Match Meth Resol Def]} {
set PdbInfo($Acc,def) [string trim $Def]
set PdbInfo($Acc,met) [string trim $Meth]
set PdbInfo($Acc,res) [string trim $Resol]
continue
}
if {[regexp {(Theoret model) (.+)$} $Ligne Match Meth Def]} {
set PdbInfo($Acc,def) [string trim $Def]
continue
}
FaireLire $Ligne
continue
}
if {$Meth==""} { set Meth "-" }
regsub -all -- {\*} $T "\\*" xT
regsub -all -- {\-} $xT "\\-" xT
regsub -all -- {\-} $Date "\\-" xDate
regsub -all -- {\-} $Meth "\\-" xMeth
regsub "$Acc +$xT +$xDate +$xMeth" $Ligne "" ResDef
scan $ResDef "%s" Resol
regsub -all -- {\-} $Resol "\\-" Resol
regsub -- "$Resol +" $ResDef "" Def
if { ! [regexp {^[0-9\.]+$} $Resol]} { set Resol "" }
set PdbInfo($Acc,def) [string trim $Def]
set PdbInfo($Acc,dat) [string trim $Date]
set PdbInfo($Acc,met) [string trim $Meth]
set PdbInfo($Acc,res) [string trim $Resol]
}
foreach Acc [PdbInfo listof acc] {
set Def $PdbInfo($Acc,def)
if {[info exists PdbInfo($Acc,dat)]} { append Def " $PdbInfo($Acc,dat)" }
if {[info exists PdbInfo($Acc,met)] && $PdbInfo($Acc,met)!="Theoret"} { append Def " $PdbInfo($Acc,met)" }
if {[info exists PdbInfo($Acc,res)]} { append Def " $PdbInfo($Acc,res)" }
set PdbInfo($Acc,def) $Def
}
return [PdbInfo $Qui $Quoi]
}
proc PdbSeqRes {{Qui ""} {Quoi ""}} {
global PdbSeqRes
if {[info exists PdbSeqRes($Qui,$Quoi)]} { return $PdbSeqRes($Qui,$Quoi) }
if {[info exists PdbSeqRes("EstCharge")]} { return "" }
set PdbSeqRes("EstCharge") 1
set FichierSeqRes "./pdb_seqres.txt"
foreach Ligne [LesLignesDuFichier $FichierSeqRes] {
if {[regexp ">" $Ligne]} {
scan $Ligne "%s" AccChain
regsub ">" $AccChain "" AccChain
lappend PdbSeqRes(listof,acc) $AccChain
set PdbSeqRes($AccChain,seq) ""
regsub {.*length\:[0-9]+ +} $Ligne "" Titre
set PdbSeqRes($AccChain,tit) $Titre
continue
}
set Ligne [string trim $Ligne]
append PdbSeqRes($AccChain,seq) $Ligne
}
foreach AccChain $PdbSeqRes(listof,acc) {
regsub {_[A-Z]+} $AccChain "" Acc
set acc [string tolower $Acc]
set Def [PdbInfo $acc def]
set Entete ">PDB:$AccChain $PdbSeqRes($AccChain,tit)."
if {$Def!=""} { append Entete " $Def" }
set Seq $PdbSeqRes($AccChain,seq)
if {[regexp -nocase {[^a-z]} $Seq]} { Espionne "$Acc $Seq" }
set Tfa [SequenceFormatTFA $Seq $Entete "protbrut"]
set PdbSeqRes($AccChain,tfa) $Tfa
set ACCCHAIN [string toupper $AccChain]
if {$AccChain!=$ACCCHAIN} {
set PdbSeqRes($ACCCHAIN,tfa) $Tfa
set PdbSeqRes($ACCCHAIN,seq) $Seq
}
}
return [PdbSeqRes $Qui $Quoi]
}
proc CreatePdbFromSeqResAndProtName {{Sortie ""}} {
foreach Acc [PdbSeqRes listof acc] {
set Tfa [PdbSeqRes $Acc tfa]
lappend LeTfa $Tfa
}
set GrosTfa [join $LeTfa "\n"]
if {$Sortie==""} {return $GrosTfa }
return [Sauve $GrosTfa dans $Sortie]
}
proc BonneEntetePourBilanCilio Header {
global BonneEntetePourBilanCilio
set HEADER [string toupper $Header]
if {[info exists BonneEntetePourBilanCilio($HEADER)]} { return $BonneEntetePourBilanCilio($HEADER) }
if {[info exists BonneEntetePourBilanCilio("EstCharge")]} { return $Header }
set BonneEntetePourBilanCilio("EstCharge") 1
set LookupList [list \
"In_GoldStandard" "InGoldStandard" \
"GScope" "GscopeId" \
"Uniprot ID" "UniprotId" \
"In orthoinspector" "InOrthoinspector" \
"Groupe de paralogue" "GroupOfParalog" \
"GO" - \
"Function" - \
"Citation" - \
"ProteinName" - \
"Uniprot Total" "UniprotTotal" \
"Genomique comparative" "ComparativeGenomics" \
"Proteomique" - \
"Transcriptomique" "Trasncriptomics" \
"Promoteur X-Box" "PromoteurX-Box" \
"Total" - \
"Prediction" - \
"Phylum specific" "PhylumSpecific" \
"Ciliated-specific" "CiliatedSpecific" \
"Diff Stramenopile" "DiffStramenopile" \
"Diff Archaeplastidae" "Diff Archaeplastidae" \
"Diff Alveolata" "DiffAlveolata" \
"Diff Fungi" "DiffFungi" \
"Nb de clades ciliés" "NbCladesCilies" \
"Nb de clades non ciliés" "NbCladesNonCilies" \
"Nb de PR" "NbPR" \
"Universal" "Universal" \
"Nb Diff" "NbDiff" \
]
foreach {K V} $LookupList {
if {$V=="-"} { set V $K }
set BonneEntetePourBilanCilio([string toupper $K]) $V
}
return [BonneEntetePourBilanCilio $Header]
}
proc BilanCilio2014 {{Qui ""} {Quoi ""}} {
global BilanCilio2014
#rR on lit le fichier Excel de Odile
#rR gscope puts BilanCilio2014 ListOf Usage
if {[info exists BilanCilio2014($Qui,$Quoi)]} { return $BilanCilio2014($Qui,$Quoi) }
if {[info exists BilanCilio2014("EstCharge")]} {
if {$Qui=="ListOf" && $Quoi=="Example"} {
set LesExemples {}
foreach Us $BilanCilio2014(ListOf,Usage) {
if { ! [regexp "^Bilan" $Us]} { continue }
lappend LesExemples "\n$Us"
lappend LesExemples [eval $Us]
}
lappend LesExemples "\nYou can run all these commands with :"
lappend LesExemples "gscope puts BilanCilio2014 Y_Mammalia TaxId"
return [join $LesExemples "\n"]
}
return ""
}
set BilanCilio2014("EstCharge") 1
set Fichier "[RepertoireDuGenome]/fiches/bilan_presence_absence_avecgroupes_tentativescriteres.csv"
if {[FileAbsent $Fichier]} { unset BilanCilio2014; return "" }
set BilanCilio2014(exists,) 1
set Usage [list \
"gscope puts BilanCilio2014 ListOf Usage" \
"BilanCilio2014 ListOf Box" \
"BilanCilio2014 ListOf Access" \
"BilanCilio2014 ListOf Categories" \
"BilanCilio2014 ListOf TaxId" \
"BilanCilio2014 ListOf Class" \
"BilanCilio2014 ListOf Clade" \
"" \
"BilanCilio2014 10090 Class" \
"BilanCilio2014 10090 Clade" \
"BilanCilio2014 10090 State" \
"BilanCilio2014 10090 PA" \
"" \
"BilanCilio2014 Y_Mammalia TaxId" \
"BilanCilio2014 Y_Mammalia State" \
"BilanCilio2014 Y_Mammalia States" \
"BilanCilio2014 Y_Mammalia Count" \
"BilanCilio2014 Y_Mammalia PA" \
"" \
]
set BilanCilio2014(ListOf,Usage) $Usage
set BilanCilio2014(Filename,) $Fichier
set Texte [ContenuDuFichier $Fichier]
regsub -all "\n\"" $Texte "\"" Texte
set Prems 1
set Deuss 0
set Trois 0
set LesTaxId {}
set LesTaxIdsDuG {}
set LesEtatsDuG {}
set LesEspecesDuG {}
set LesClades {}
foreach Ligne [split $Texte "\n"] {
if {$Prems} {
set Prems 0
set Deuss 1
set LesBox [lrange [split $Ligne ";"] 4 end]
set BilanCilio2014(ListOf,Box) $LesBox
continue
}
if {$Deuss} { set Trois 1; set Deuss 0 ; continue }
if {$Trois} { set Trois 0; set BilanCilio2014(ListOf,Categories) [lrange [split $Ligne ";"] 4 end]; continue }
set Classe ""
if {[regexp {;\"([^\"]+)\";} $Ligne Match Classe]} {
regsub {;\"([^\"])+\";} $Ligne ";Classe;" Ligne
}
set LesMots [split $Ligne ";"]
set TaxId [string trim [lindex $LesMots 0] " -"]
set Espece [string trim [lindex $LesMots 1] " -"]
set Clade [string trim [lindex $LesMots 2] " -"]
set Etat [string trim [lindex $LesMots 3] " -"]
if {$TaxId=="" && $Espece=="" && $Clade=="" && $Etat==""} {
set LesAccess [lrange $LesMots 4 end]
set BilanCilio2014(ListOf,Access) $LesAccess
break
}
set Clade "${Etat}_$Clade"
regsub -all " +" $Clade "_" Clade
if {[regexp {^[0-9]+$} $TaxId]} {
lappend LesTaxIdsDuG $TaxId
lappend LesEspecesDuG $Espece
lappend LesEtatsDuG $Etat
lappend LesClassesDuG $Classe
lappend BilanCilio2014(ListOf,TaxId) $TaxId
lappend BilanCilio2014(ListOf,Class) $Classe
set BilanCilio2014($TaxId,PA) [lrange $LesMots 4 end]
set BilanCilio2014($TaxId,State) $Etat
set BilanCilio2014($TaxId,Class) $Classe
set BilanCilio2014($Classe,TaxId) $TaxId
} else {
set Compte $Espece
lappend BilanCilio2014(ListOf,Clade) $Clade
set BilanCilio2014($Clade,Count) $Compte
set BilanCilio2014($Clade,State) $Etat
set BilanCilio2014($Clade,TaxId) $LesTaxIdsDuG
set BilanCilio2014($Clade,Species) $LesEspecesDuG
set BilanCilio2014($Clade,States) $LesEtatsDuG
set BilanCilio2014($Clade,Class) $LesClassesDuG
set BilanCilio2014($Clade,TaxId) $LesTaxIdsDuG
set BilanCilio2014($Clade,PA) [lrange $LesMots 4 end]
foreach TaxId $LesTaxIdsDuG {
set BilanCilio2014($TaxId,Clade) $Clade
set BilanCilio2014($TaxId,Clade) $Clade
}
set LesTaxIdsDuG {}
set LesEtatsDuG {}
set LesEspecesDuG {}
}
}
foreach S [array names BilanCilio2014 "10090,*"] {
regsub 10090 $S 9606 H
Espionne "$S $H"
set BilanCilio2014($H) $BilanCilio2014($S)
}
regsub -all 0 $BilanCilio2014(10090,PA) 1 BilanCilio2014(9606,PA)
return [BilanCilio2014 $Qui $Quoi]
}
proc SelectClade {{Multiple ""} {UseQds ""}} {
if {$Multiple==""} { set Multiple "One" }
set GetAll [string equal -nocase "GetAll" $Multiple]
set Multiple [string equal -nocase "Multiple" $Multiple]
set UseQds [string equal -nocase "UseQds" $UseQds]
if {[OnTraite "CilioCarta" "Like"]} {
if {$UseQds} {
set LesBilCla [QuestionDeScience CilioCarta "ret BilanCilio ListOf Clade"]
} else {
set LesBilCla [BilanCilio ListOf Clade]
}
set LesClades {}
foreach BilCla $LesBilCla {
regsub {[^_]+_} $BilCla "" Clade ;#rR on enleve Y_ N_ et PR_
lappend LesClades $Clade
}
set LesClades [lsort -unique $LesClades]
} elseif {[OnTraite "OI2017" "Like"]} {
if {$UseQds} {
set LesClades [QuestionDeScience OI "ret CMC ListOf Clade"]
} else {
set LesClades [CMC ListOf Clade]
}
set LesClades [lsort -unique $LesClades]
}
if {$GetAll} { return $LesClades }
if {$Multiple} {
if {[OnTraite "CilioCarta"]} { return [lrange $LesClades 0 end] }
set Choisis [Affiche [join $LesClades "\n"] "AvecRetour" "Select within this list. Highlight several and press 'Validate selection' or 'All'"]
return [split $Choisis "\n"]
}
set LesClades [linsert $LesClades 0 "Use another one"]
set Choisi [ChoixParmi $LesClades]
if {$Choisi=="Use another one"} { set Choisi [Entre "Hominidae"] }
return $Choisi
}
proc BilanCilioQds {{Qui ""} {Quoi ""}} {
return [QuestionDeScience CilioCarta "ret BilanCilio $Qui $Quoi"]
}
proc CladeContent {Clade {UseQds ""} {WithoutTaxIds ""}} {
#rR WithoutTaxIds est une liste de TaxIds qu'il faut ne pas considérer (typiquement 9606)
#rR UseQds Pour aller plus vite ... mais attention à ne pas le faire en QDS
if {$UseQds=="UseQds" && ( ! [OnTraite CilioCarta] || ! [PourWscope]) } {
return [QuestionDeScience CilioCarta "ret CladeContent $Clade Direct $WithoutTaxIds"]
}
set WithoutTaxIds [split $WithoutTaxIds ","]
set Content {}
foreach S {Y PR N} {
if {[regexp {([A-Z]+)_} $Clade Match X]} {
if {$S!=$X} { Espionne $Clade; continue }
set C [BilanCilio $Clade "CladeContentTaxIds"]
} else {
set C [BilanCilio "${S}_$Clade" "CladeContentTaxIds"]
}
foreach TaxId $C {
if {[lsearch $WithoutTaxIds $TaxId]>=0} { continue }
lappend Content $TaxId
}
}
return $Content
}
proc BilanCilio {{Qui ""} {Quoi ""}} {
global BilanCilio
if {[OnTraite CilioCarta2014]} { return [BilanCilio2014 $Qui $Quoi] }
#rR on lit le fichier Excel de Odile
#rR gscope puts BilanCilio ListOf Usage
if {[info exists BilanCilio($Qui,$Quoi)]} { return $BilanCilio($Qui,$Quoi) }
if {[info exists BilanCilio("EstCharge")]} {
regsub -all "_" $Qui " " Qi
regsub -all "_" $Quoi " " Qo
if {[info exists BilanCilio($Qui,$Qo)] } { return $BilanCilio($Qui,$Qo) }
if {[info exists BilanCilio($Qi,$Quoi)]} { return $BilanCilio($Qi,$Quoi) }
if {[info exists BilanCilio($Qui,Column)] && [info exists BilanCilio($BilanCilio($Qui,Column),$Quoi)]} { return $BilanCilio($BilanCilio($Qui,Column),$Quoi) }
if {[info exists BilanCilio($Qi,Column)] && [info exists BilanCilio($BilanCilio($Qi,Column),$Quoi)]} { return $BilanCilio($BilanCilio($Qi,Column),$Quoi) }
if {[info exists BilanCilio($Qui,Column)] && [info exists BilanCilio($BilanCilio($Qui,Column),$Qo)]} { return $BilanCilio($BilanCilio($Qui,Column),$Qo) }
if {[info exists BilanCilio($Qi,Column)] && [info exists BilanCilio($BilanCilio($Qi,Column),$Qo)]} { return $BilanCilio($BilanCilio($Qi,Column),$Qo) }
if {$Qui=="Example"} {
set LesExemples {}
foreach Us $BilanCilio(ListOf,Usage) {
if { ! [regexp "^Bilan" $Us]} { continue }
lappend LesExemples "\n$Us"
set Res [eval $Us]
if {[string length $Res]>100} { set Res "[string range $Res 0 132] ..." }
lappend LesExemples $Res
}
lappend LesExemples "\nYou can run all these commands with :"
lappend LesExemples "gscope puts BilanCilio N_Fungi TaxId"
return [join $LesExemples "\n"]
}
return ""
}
set BilanCilio("EstCharge") 1
#rR ************************************************** attention il faut le fichier sinon return 0 si on demande exists vide autrement
# set Fichier "[RepertoireDuGenome]/bilan/bilanOK.csv"
set Fichier "/genomics/link/CilioCarta/bilan/bilanOK.csv"
if {[FileAbsent $Fichier]} {
unset BilanCilio
if {$Qui=="exists"} { return 0 }
return ""
}
set BilanCilio(exists,) 1
set ListOfUsage [list \
"gscope puts BilanCilio Usage" \
"gscope puts BilanCilio Example" \
"BilanCilio ListOf GscopeId" \
"BilanCilio ListOf UniprotId" \
"BilanCilio ListOf TaxId" \
"BilanCilio ListOf Class" \
"BilanCilio ListOf Clade" \
"" \
"BilanCilio 10090 Species" \
"BilanCilio 10090 Class" \
"BilanCilio 10090 Clade" \
"BilanCilio 10090 State" \
"BilanCilio 10090 TaxId" \
"" \
"BilanCilio (556484_12968) Column" \
"BilanCilio (556484_12968) Clade" \
"" \
"BilanCilio Y_Fungi TaxId" \
"BilanCilio Y_Fungi CladeContentTaxIds" \
"BilanCilio Y_Fungi CladeContentSpecies" \
"BilanCilio Y_Fungi CladeContentColumns" \
"BilanCilio N_Fungi Permil" \
"BilanCilio PR_Fungi Count" \
"" \
]
set BilanCilio(ListOf,Usage) $ListOfUsage
set BilanCilio(Usage,) [join $ListOfUsage "\n"]
set BilanCilio(Filename,) $Fichier
set Texte [ContenuDuFichier $Fichier]
regsub -all "\n\"" $Texte "\"" Texte
set CladeContentTaxIds {}
set CladeContentSpecies {}
set CladeContentColumns {}
set Prems 1
set Deuss 0
set Trois 0
set Quats 0
set N 0
foreach Ligne [split $Texte "\n"] {
if {0 && [incr N]==1000} { break }
if {$Prems} {
set Prems 0
set Deuss 1
set LesTaxIdLus [lrange [split $Ligne ";"] 5 end]
set Column 5
set CladeContentTaxIds {}
set LesTaxId {}
foreach TaxId $LesTaxIdLus {
if {$TaxId==""} {
if {$CladeContentTaxIds=={}} { break }
set TaxId "([join $CladeContentTaxIds { }])"
lappend BilanCilio(ListOf,CladeTaxIds) $TaxId
set BilanCilio($Column,CladeContentTaxIds) $CladeContentTaxIds
set BilanCilio($Column,CladeContentColumns) $CladeContentColumns
set CladeContentColumns {}
set CladeContentTaxIds {}
} else {
lappend CladeContentColumns $Column
lappend CladeContentTaxIds $TaxId
lappend BilanCilio(ListOf,TaxId) $TaxId
}
set BilanCilio($TaxId,Column) $Column
set BilanCilio($Column,TaxId) $TaxId
incr Column
}
continue
}
if {$Deuss} {
set Trois 1
set Deuss 0
set LesEspecesLus [lrange [split $Ligne ";"] 5 end]
set Column 5
set LesEspeces {}
foreach Espece $LesEspecesLus {
regsub { \(.+\) *$} $Espece "" Espece
if {$Espece==""} { break }
set TaxId $BilanCilio($Column,TaxId)
if {[regexp {^[0-9]+$} $Espece]} {
set TailleClade $Espece
set BilanCilio($Column,CladeContentSize) $TailleClade
set BilanCilio($Column,IsClade) 1
set BilanCilio($Column,CladeContentSpecies) $CladeContentSpecies
lappend BilanCilio(ListOf,CladeColumn) $Column
set CladeContentSpecies {}
} else {
lappend CladeContentSpecies $Espece
lappend BilanCilio(ListOf,Species) $Espece
lappend BilanCilio(ListOf,SpeciesColumn) $Column
set BilanCilio($Column,TaxId) $TaxId
set BilanCilio($Column,Species) $Espece
set BilanCilio($Espece,TaxId) $TaxId
set BilanCilio($TaxId,OS) $Espece
regsub -all " " $BilanCilio($TaxId,OS) "_" BilanCilio($TaxId,OS_)
}
incr Column
}
continue
}
if {$Trois} {
set Trois 0
set Quats 1
#rR attention il y a des ; protégés par de "" on les remplace par 1 2 3 etc.
set iC 0
while {[regexp {;\"([^\"]+)\";} $Ligne Match Class]} {
set ClassMemo($iC) $Class
regsub {;\"([^\"])+\";} $Ligne ";$iC;" Ligne
incr iC
}
set LesClassLus [lrange [split $Ligne ";"] 5 end]
set Column 5
set LesEspeces {}
foreach Class $LesClassLus {
if {[info exists ClassMemo($Class)]} { set Class $ClassMemo($Class) }
if {$Class==""} { break }
set TaxId $BilanCilio($Column,TaxId)
if {[info exists BilanCilio($Column,IsClade)]} {
#rR ici on a le clade seul et non pas la classe de l'espèce.
set CladeSeul $Class
set BilanCilio($Column,CladeSeul) $CladeSeul
#rR il faut attendre la ligne 4 pour avoir les Y PR N
} else {
set BilanCilio($Column,DoCount) 1
set BilanCilio($Column,TaxId) $TaxId
set BilanCilio($Column,Class) $Class
}
lappend BilanCilio(ListOf,Class) $Class ; #rR attention les clades font partie de la liste des classes
incr Column
}
continue
}
if {$Quats} {
set Quats 0
set LesHeadersLus [split $Ligne ";"]
set Column 0
set LesHeaders {}
foreach Header $LesHeadersLus {
if {$Column==0} { set Header "Comment" }
regsub {\([^\(]+\)} $Header "" Header
if {$Header==""} { break }
set Header [string trim $Header]
set Header [BonneEntetePourBilanCilio $Header]
if {[regexp {^(Y|PR|N)$} $Header]} {
set Etat $Header
set TaxId $BilanCilio($Column,TaxId)
if {[info exists BilanCilio($Column,CladeSeul)]} {
set CladeSeul $BilanCilio($Column,CladeSeul)
set EtatClade "${Etat}_$CladeSeul"
set BilanCilio($Column,Clade) $EtatClade
set BilanCilio($EtatClade,Column) $Column
set BilanCilio($TaxId,Clade) $EtatClade
lappend BilanCilio(ListOf,Clade) $EtatClade
set Header $EtatClade
} else {
set Species $BilanCilio($Column,Species)
set SpeciesEtat "${Species} $Etat"
set BilanCilio($SpeciesEtat,Column) $Column
set BilanCilio($SpeciesEtat,TaxId) $TaxId
set BilanCilio($SpeciesEtat,Class) $BilanCilio($Column,Class)
#set Header $SpeciesEtat
set Header $Species
}
set BilanCilio($Column,State) $Etat
}
set HeaderUnderscore $Header
regsub -all " " $HeaderUnderscore "_" HeaderUnderscore
regsub -all {[\(\)]} $HeaderUnderscore "" HeaderUnderscore
set BilanCilio($Column,Header) $HeaderUnderscore
set BilanCilio($Header,Column) $Column
set BilanCilio($HeaderUnderscore,Column) $Column
lappend BilanCilio(ListOf,Header) $HeaderUnderscore
incr Column
}
continue
}
#rR maintenant il faut lire les données et les affecter en fonction de la column
set LesMots [split $Ligne ";"]
lassign $LesMots Comment InGoldStandard GscopeId UniprotId InOrthoinspector
set G $GscopeId
lappend BilanCilio(ListOf,GscopeId) $GscopeId
foreach K {Comment InGoldStandard GscopeId UniprotId InOrthoinspector} {
set BilanCilio($G,$K) [set $K]
}
set L [llength $BilanCilio(ListOf,Header)]; incr L -1
foreach H $BilanCilio(ListOf,Header) Value [lrange $LesMots 0 $L] {
set BilanCilio($G,$H) $Value
}
}
set BilanCilio(ListOf,JoinedClade) {}
foreach Clade $BilanCilio(ListOf,Clade) {
regsub {^[YNPR]+_} $Clade "" JoinedClade
lappend BilanCilio(ListOf,JoinedClade) $JoinedClade
if { ! [info exists BilanCilio($JoinedClade,CladeContentTaxIds)]} {
set BilanCilio($JoinedClade,CladeContentTaxIds) {}
set BilanCilio($JoinedClade,CladeContentSpecies) {}
}
# LConcat BilanCilio($JoinedClade,CladeContentTaxIds) $BilanCilio($Clade,CladeContentTaxIds)
# LConcat BilanCilio($JoinedClade,CladeContentSpecies) $BilanCilio($Clade,CladeContentSpecies)
}
set BilanCilio(ListOf,JoinedClade) [lsort -unique $BilanCilio(ListOf,JoinedClade)]
foreach CladeColumn $BilanCilio(ListOf,CladeColumn) {
foreach Column $BilanCilio($CladeColumn,CladeContentColumns) {
set BilanCilio($Column,CladeColumn) $CladeColumn
set BilanCilio($Column,Clade) $BilanCilio($CladeColumn,Clade)
}
}
set NG 0
foreach G $BilanCilio(ListOf,GscopeId) {
incr NG
set U $BilanCilio($G,UniprotId)
lappend BilanCilio(ListOf,UniprotId) $U
set Column 0
foreach H $BilanCilio(ListOf,Header) {
set BilanCilio($U,$H) $BilanCilio($G,$H)
if {[info exists BilanCilio($Column,DoCount)] && $BilanCilio($G,$H)==1 } { incr BilanCilio($H,Count) $BilanCilio($G,$H)}
incr Column
}
}
foreach H $BilanCilio(ListOf,Header) {
if { ! [info exists BilanCilio($H,Count)]} { set BilanCilio($H,Count) 0 }
set BilanCilio($H,Permil) [expr round($BilanCilio($H,Count)*1000./$NG)]
regsub -all " " $H "_" H
lappend BilanCilio(ListOf,Usage) "BilanCilio HSAP00001 $H"
}
set BilanCilio(ListOf,UniprotId) [lsort $BilanCilio(ListOf,UniprotId)]
if {0} {
foreach S [array names BilanCilio "10090,*"] {
regsub 10090 $S 9606 H
Espionne "$S $H"
set BilanCilio($H) $BilanCilio($S)
}
regsub -all 0 $BilanCilio(10090,State) 1 BilanCilio(9606,State)
set BilanCilio(9606,Species) "Homo sapiens"
set BilanCilio(9606,TaxId) 9606
}
set BilanCilio(9606,Clade) $BilanCilio($BilanCilio(10090,Column),Clade)
set BilanCilio(9606,State) "Y"
return [BilanCilio $Qui $Quoi]
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.