Index by: file name |
procedure name |
procedure call |
annotation
gscope_olymclade.tcl
(annotations | original source)
#fS gscope_olymclade.tcl les OLYMpiades pour les CLADEs
#rR on y fait concourir des clades pour savoir comment ils se comportent dans les blast
proc LesBacteriesDeClaudine {{GetWhat ""}} {
set Groupe1 {
"Mycobacterium tuberculosis H37Rv"
"Helicobacter pylori g27"
"Deinococcus radiodurans r1"
"Treponema pallidum ss14"
}
set Groupe2 {
"Escherichia coli atcc8739"
"Staphylococcus aureus mu50"
"Streptococcus pneumoniae R6"
"Thermus thermophilus hb27"
"Mycoplasma genitalium G-37"
}
set LesBons {}
foreach Clau [concat $Groupe1 $Groupe2] {
scan $Clau "%s %s %s" G E S
Espionne
Espionne $Clau
set LesPossibles [glob -nocomplain "/genomics/link/OrthoInspector_Proteomes/Bacteria/NotaBene/*${G}_${E}*"]
if {[llength $LesPossibles]!=1} {
set LesMeilleurs [glob -nocomplain "/genomics/link/OrthoInspector_Proteomes/Bacteria/NotaBene/*${G}_${E}*${S}*"]
if {[llength $LesMeilleurs]==1} {
set LesPossibles $LesMeilleurs
}
}
if {[llength $LesPossibles]!=1} {
Espionne "***************************************************** lequel je prends parmi les suivants ?"
foreach Possible $LesPossibles {
Espionne [file tail $Possible]
}
} else {
Espionne [file tail [lindex $LesPossibles 0]]
}
lappend LesBons [lindex $LesPossibles 0]
}
foreach Bon $LesBons {
set N [regexp -all ">" [ContenuDuFichier $Bon]]
set Queue [file tail $Bon]
regsub -all "_" $Queue " " Queue
lappend LesQueues $Queue
scan $Queue "%s" OI
Espionne $OI $N
}
if {$GetWhat=="GetFiles"} { return $LesBons }
return $LesQueues
}
proc JoyFungi {{FileToCreate ""}} {
#rR Parmi tous les fungi on veut mettre les JoyOXOS en début puis les autres
#rR Ceci pour créer un Paraph (Paraphylum) voir plus bas la proc.
#rR On teste d'abord le OX .. fastoce ... mais si on ne le trouve pas on teste l'OS
#rR et par chance il se trouve que les OS des Joy non trouvés n'ont que 2 mots ... et sont uniques dans notre cas :-)
set LesFungiOXOS [OiDescendants Fungi OXOS]
set LesJoyOXOS [JoyCode ListOf OXOS]
foreach OXOS $LesFungiOXOS {
set Trouve 0
if { ! [regexp {^([0-9]+) (.+)$} $OXOS Match OX OS]} { FaireLire "Wrong $OXOS" }
#rR Je cherche d'abord s'il est un des Joy en OX
foreach JoyOXOS $LesJoyOXOS {
if { ! [regexp {^([0-9]+) (.+)$} $JoyOXOS Match JoyOX JoyOS]} { FaireLire "Wrong $JoyOXOS" }
if {$OX==$JoyOX} {
lappend LesElus $OXOS
set Trouve 1
set OkPour($OS) 1
break
}
}
if {$Trouve} { continue }
#rR Je cherche ensuite s'il est un des Joy en OS
foreach JoyOXOS $LesJoyOXOS {
if { ! [regexp {^([0-9]+) (.+)$} $JoyOXOS Match JoyOX JoyOS]} { FaireLire "Wrong $JoyOXOS" }
if {[info exists OkPour($OS)]} { set Trouve 1 ; break }
if {[regexp "^$JoyOS" $OS]} {
lappend LesElus $OXOS
set Trouve 1
break
}
}
if {$Trouve} { continue }
lappend LePeuple $OXOS
}
set LesJoyFungiOrdonnes {}
lappend LesJoyFungiOrdonnes "JoysBand"
LConcat LesJoyFungiOrdonnes $LesElus
lappend LesJoyFungiOrdonnes "OtherFungi"
LConcat LesJoyFungiOrdonnes $LePeuple
if {$FileToCreate!=""} {
SauveLesLignes $LesJoyFungiOrdonnes dans $FileToCreate
return $FileToCreate
}
return $LesJoyFungiOrdonnes
}
proc OiDescendants {{Node ""} {GetWhat ""}} {
#rR Attentionon utilise un fichier memo pour aller plus vite ... Penser à l'effacer si changement
global OiDescendants
if {$GetWhat==""} { set GetWhat OX }
set Found 0
if { ! $Found && [regexp -nocase "OX" $GetWhat] && [regexp -nocase "OS" $GetWhat]} { set Found 1; set GetWhat "OXOS" }
if { ! $Found && [regexp -nocase "OX" $GetWhat]} { set Found 1; set GetWhat "OX" }
if { ! $Found && [regexp -nocase "OS" $GetWhat]} { set Found 1; set GetWhat "OS" }
if { ! $Found && [regexp -nocase "CL" $GetWhat]} { set Found 1; set GetWhat "CL" }
if {[info exists OiDescendants($Node,$GetWhat)]} { return $OiDescendants($Node,$GetWhat) }
if {[info exists OiDescendants($Node,Loaded)]} { return "" }
set OiDescendants($Node,Loaded) 1
set OiDescendants($Node,File) "[BlastomicsDir]/OiDescendants_$Node.txt"
if {[file exists $OiDescendants($Node,File)]} {
array set OiDescendants [ContenuDuFichier $OiDescendants($Node,File)]
return [OiDescendants $Node $GetWhat]
}
set OxNode [Tax $Node "TaxId"]
set LesClasses {}
foreach OX [OiCode ListOf OX] {
if { ! [JeSuisTonAncetre $OxNode $OX]} { continue }
set Classe [TaxClass $OX Name]
regsub {^ *; *cellular organisms; *} $Classe "" Classe
lappend LesClasses $Classe
set OxDeLaClasse($Classe) $OX
}
set LesClasses [lsort $LesClasses]
set LesOX {}
set LesOS {}
set LesOXOS {}
foreach Classe $LesClasses {
set OX $OxDeLaClasse($Classe)
set OS [Tax $OX "Name"]
lappend LesOX $OX
lappend LesOS $OS
lappend LesOXOS "$OX $OS"
}
set OiDescendants($Node,OXOS) $LesOXOS
set OiDescendants($Node,OX) $LesOX
set OiDescendants($Node,OS) $LesOS
set OiDescendants($Node,CL) $LesClasses
Sauve [array get OiDescendants] dans $OiDescendants($Node,File)
return [OiDescendants $Node $GetWhat]
}
proc PhylAr {{Qui ""} {Quoi ""}} {
JeMeSignale
global PhylAr
if {[info exists PhylAr($Qui,$Quoi)]} { return $PhylAr($Qui,$Quoi) }
if {[info exists PhylAr("EstCharge")]} { return "" }
set PhylAr("EstCharge") 1
set FichierMemo "/genomics/link/OI/fiches/phylar.txt"
if {[regexp -nocase "^ReDo_" $Qui]} {
if {[file exists $FichierMemo]} { file delete $FichierMemo }
regsub -nocase "^ReDo_" $Qui "" Qui
unset PhylAr
return [PhylAr $Qui $Quoi]
}
if {[file exists $FichierMemo]} {
array set PhylAr [ContenuDuFichier $FichierMemo]
return [PhylAr $Qui $Quoi]
}
OiDomain Archaea
set LesPhyOX [ArClade ListOf AllOX]
set LesPhyOS [ArClade ListOf AllName]
foreach OX [OiCode ListOf OX] {
set OS [OiCode $OX OS]
lappend PhylAr(ListOf,OX) $OX
lappend PhylAr(ListOf,OS) $OS
set PasTrouve 1
foreach PhyOX $LesPhyOX {
set PhyOS [ArClade $PhyOX Name]
set PhylAr($PhyOX,PhyOX) $PhyOX
set PhylAr($PhyOX,PhyOS) $PhyOS
set PhylAr($PhyOS,PhyOX) $PhyOX
set PhylAr($PhyOS,PhyOS) $PhyOS
if {[JeSuisTonAncetre $PhyOX $OX]} {
set PhylAr($OX,PhyOX) $PhyOX
set PhylAr($OX,PhyOS) $PhyOS
set PhylAr($OS,PhyOX) $PhyOX
set PhylAr($OS,PhyOS) $PhyOS
lappend PhylAr($PhyOX,ListOfOX) $OX
lappend PhylAr($PhyOX,ListOfOS) $OS
lappend PhylAr($PhyOS,ListOfOX) $OX
lappend PhylAr($PhyOS,ListOfOS) $OS
set PasTrouve 0
break
}
}
if {$PasTrouve} { FaireLire "Impossible de caser\n$OX $OS"}
}
set LesPhyOXNonVides {}
set LesPhyOYNonVides {}
foreach PhyOX $LesPhyOX PhyOS $LesPhyOS {
if { ! [info exists PhylAr($PhyOX,ListOfOX)]} { continue }
lappend LesPhyOXNonVides $PhyOX
lappend LesPhyOSNonVides $PhyOS
}
set PhylAr(ListOf,PhyOX) $LesPhyOXNonVides
set PhylAr(ListOf,PhyOS) $LesPhyOSNonVides
Sauve [array get PhylAr] dans $FichierMemo
return [PhylAr $Qui $Quoi]
}
proc GeneIdWithGoDict {{Bdd ""}} {
}
proc TaxoblaProject {{Qui ""} {Quoi ""}} {
global TaxoblaProject
set FichierMemo "/genomics/link/OI/fiches/TaxoblaProject.txt"
if {[regexp -nocase "^ReDo_" $Qui]} {
if {[file exists $FichierMemo]} { file delete $FichierMemo }
regsub -nocase "^ReDo_" $Qui "" Qui
if {[info exists TaxoblaProject]} { unset TaxoblaProject }
return [TaxoblaProject $Qui $Quoi]
}
if {[info exists TaxoblaProject($Qui,$Quoi)]} { return $TaxoblaProject($Qui,$Quoi) }
if {[info exists TaxoblaProject("EstCharge")]} { return "" }
set TaxoblaProject("EstCharge") 1
if {[file exists $FichierMemo]} {
array set TaxoblaProject [ContenuDuFichier $FichierMemo]
return [TaxoblaProject $Qui $Quoi]
}
set LesRepExistants [glob -nocomplain "/genomics/link/*/taxobla"]
foreach RepT $LesRepExistants {
set Rep [file dirname $RepT]
set LesProttfa [lsort [glob -nocomplain "$Rep/prottfa/*"]]
if { [set NbProttfa [llength $LesProttfa]] < 10} { continue }
set LesTaxobla [lsort [glob -nocomplain "$Rep/taxobla/*"]]
set Projet [file tail $Rep]
if { [set NbTaxobla [llength $LesTaxobla]] < $NbProttfa } { Espionne "$Projet $NbTaxobla/$NbProttfa" ; continue }
lappend LesProjets [file tail $Rep]
set OX [IntegerApres "NotreOX" dans [ContenuDuFichier "$Rep/beton/miniconfig"]]
set TaxoblaProject($Projet,NS) $NbProttfa
set TaxoblaProject($Projet,NT) $NbTaxobla
set TaxoblaProject($Projet,OX) $OX
}
set TaxoblaProject(ListOf,Project) [lsort -unique $LesProjets]
Sauve [array get TaxoblaProject] dans $FichierMemo
return [TaxoblaProject $Qui $Quoi]
}
proc SshScore {{Query ""} {Subject ""}} {
#rR SequenceSizeHomologyScore
set OxQ [OiCode $Query OX]
set OxS [OiCode $Subject OX]
set OiQ [OiCode $Query OI]
set OiS [OiCode $Subject OI]
}
proc Paraph {{Kind ""} {Qui ""} {Quoi ""}} {
#rR Paraph (comme Paraphylum) est une généralisation de CMC ou TTLL ou PhylAr ...
#rR Les Paraphylum of Kind
#rR Attentin la même variable Paraph stocke tous les Kind ... est-ce que ça marche en même temps ? ???
global Paraph
set Separator " " ; #rR a faire .. je ne sais pas comment !
regsub -all "_" $Qui " " Qui
if {[regexp -nocase "Help" $Qui]} {
lappend LeHelp "Paraph Kind stands for Paraphylum of Kind"
lappend LeHelp "Paraph ListOf Kind"
lappend LeHelp "Paraph Kind ListOf Clade"
lappend LeHelp "Paraph Kind ListOf OX"
lappend LeHelp "Paraph Kind ListOf OS"
lappend LeHelp "Paraph Kind 9606 Clade"
lappend LeHelp "Paraph Kind Homo_sapiens Clade -> Sarcopterygii (eh oui !!! on est comme ça !!) "
lappend LeHelp "Paraph Kind 9606 Clade -> Sarcopterygii"
lappend LeHelp "Paraph Kind Sarcopterygii OX -> 7897 10090 9606 9913 9031 8364 8496 9258 13616 8469 28377"
lappend LeHelp "Paraph Kind Sarcopterygii OS -> lists the organism names"
lappend LeHelp "Paraph Kind 9606 OX -> 9606"
lappend LeHelp "Paraph Kind 9606 OS -> Homo sapiens"
lappend LeHelp "Paraph Kind Homo_sapiens OX -> 9606 (nb : with underscore _ you don't need quotes) "
lappend LeHelp "Paraph Kind Homo_sapiens OS -> Homo sapiens"
lappend LeHelp "Attention some Organims can belong to several Clades"
lappend LeHelp "Paraph Kind 12345 Clade may return several hits"
lappend LeHelp ""
lappend LeHelp " Raymond"
return [join $LeHelp "\n"]
}
set FichierCsv "[BlastomicsDir]/Paraph_$Kind.csv"
set FichierMemo "[BlastomicsDir]/Paraph_$Kind.txt"
if {[regexp -nocase "^ReDo_" $Qui]} {
if {[file exists $FichierMemo]} { file delete $FichierMemo }
regsub -nocase "^ReDo_" $Qui "" Qui
return [Paraph $Kind $Qui $Quoi]
}
if {[info exists Paraph($Kind,$Qui,$Quoi)]} { return $Paraph($Kind,$Qui,$Quoi) }
if {[info exists Paraph($Kind,"EstCharge")]} { return "" }
set Paraph($Kind,"EstCharge") 1
#rR Attention si on mémorise il faut faire redo quand il faut
#rR Mais c'est pas la peine de mémoriser ça va vite ... sauf que j'ai perdu TTLL.csv
set OnMemorise 0
if { $OnMemorise && [file exists $FichierMemo]} {
array set Paraph [ContenuDuFichier $FichierMemo]
set Paraph($Kind,csv,file) $FichierCsv
return [Paraph $Qui $Quoi]
}
set Paraph($Kind,ListOf,Clade) {}
foreach Ligne [LesLignesDuFichier $FichierCsv] {
set A ""
set B ""
if {$Separator==";"} {
lassign [split $Ligne ";"] A B
} else {
scan $Ligne "%s" A
regsub "^$A *" $Ligne "" B
}
set A [string trim $A]
set B [string trim $B]
if {[regexp -nocase {[A-Z]} $A]} {
regsub -all " " $A "" A
set Clade $A
set Paraph($Kind,$Clade,OX) {}
set Paraph($Kind,$Clade,OS) {}
lappend Paraph($Kind,ListOf,Clade) $Clade
continue
}
if {[regexp {^[0-9]+$} $A]} {
set B [Tax $A Name]
lappend Paraph($Kind,$Clade,OX) $A
lappend Paraph($Kind,$Clade,OS) $B
lappend Paraph($Kind,$A,Clade) $Clade
lappend Paraph($Kind,$B,Clade) $Clade
lappend Paraph($Kind,ListOf,OX) $A
lappend Paraph($Kind,ListOf,OS) $B
set Paraph($Kind,$A,OX) $A
set Paraph($Kind,$A,OS) $B
set Paraph($Kind,$B,OX) $A
set Paraph($Kind,$B,OS) $B
continue
}
}
set Paraph($Kind,ListOf,Clade) [lsort -unique $Paraph($Kind,ListOf,Clade)]
set Paraph($Kind,ListOf,JoinedClade) [join $Paraph($Kind,ListOf,Clade) " "]
set Paraph($Kind,ListOf,OX) [lsort -unique $Paraph($Kind,ListOf,OX)]
set Paraph($Kind,ListOf,OS) [lsort -unique $Paraph($Kind,ListOf,OS)]
if {$OnMemorise} { Sauve [array get Paraph] dans $FichierMemo }
return [Paraph $Kind $Qui $Quoi]
}
proc TTLL {{Qui ""} {Quoi ""}} {
#rR Les Clades pour les TTLL de Sarah Djeddi
global TTLL
regsub -all "_" $Qui " " Qui
if {[regexp -nocase "Help" $Qui]} {
lappend LeHelp "TTLL stands for Tubulin Tyrosine Ligase Like (from Sarah)"
lappend LeHelp "TTLL ListOf Clade"
lappend LeHelp "TTLL ListOf OX"
lappend LeHelp "TTLL ListOf OS"
lappend LeHelp "TTLL 9606 Clade"
lappend LeHelp "TTLL Homo_sapiens Clade -> Sarcopterygii (eh oui !!! on est comme ça !!) "
lappend LeHelp "TTLL 9606 Clade -> Sarcopterygii"
lappend LeHelp "TTLL Sarcopterygii OX -> 7897 10090 9606 9913 9031 8364 8496 9258 13616 8469 28377"
lappend LeHelp "TTLL Sarcopterygii OS -> lists the organism names"
lappend LeHelp "TTLL 9606 OX -> 9606"
lappend LeHelp "TTLL 9606 OS -> Homo sapiens"
lappend LeHelp "TTLL Homo_sapiens OX -> 9606 (nb : with underscore _ you don't need quotes) "
lappend LeHelp "TTLL Homo_sapiens OS -> Homo sapiens"
lappend LeHelp "Attention some Organims can belong to several Clades"
lappend LeHelp "TTLL 12345 Clade may return several hits"
lappend LeHelp ""
lappend LeHelp " Raymond"
return [join $LeHelp "\n"]
}
set FichierCsv "[BlastomicsDbDir]/TTLL.csv"
set Fichier "/genomics/link/OI/fiches/TTLL.txt"
if {[regexp -nocase "^ReDo_" $Qui]} {
if {[file exists $Fichier]} { file delete $Fichier }
regsub -nocase "^ReDo_" $Qui "" Qui
return [TTLL $Qui $Quoi]
}
if {[info exists TTLL($Qui,$Quoi)]} { return $TTLL($Qui,$Quoi) }
if {[info exists TTLL("EstCharge")]} { return "" }
set TTLL("EstCharge") 1
set OnMemorise 0 ; #rR Attention si on mémorise il faut faire redo quand il faut
if { $OnMemorise && [file exists $Fichier]} {
array set TTLL [ContenuDuFichier $Fichier]
set TTLL(csv,file) $FichierCsv
return [TTLL $Qui $Quoi]
}
set TTLL(ListOf,Clade) {}
foreach Ligne [LesLignesDuFichier $FichierCsv] {
set A ""
set B ""
lassign [split $Ligne ";"] A B
set A [string trim $A]
set B [string trim $B]
if {[regexp -nocase {[A-Z]} $A]} {
regsub -all " " $A "" A
set Clade $A
set TTLL($Clade,OX) {}
set TTLL($Clade,OS) {}
lappend TTLL(ListOf,Clade) $Clade
continue
}
if {[regexp {^[0-9]+$} $A]} {
set B [Tax $A Name]
lappend TTLL($Clade,OX) $A
lappend TTLL($Clade,OS) $B
lappend TTLL($A,Clade) $Clade
lappend TTLL($B,Clade) $Clade
lappend TTLL(ListOf,OX) $A
lappend TTLL(ListOf,OS) $B
set TTLL($A,OX) $A
set TTLL($A,OS) $B
set TTLL($B,OX) $A
set TTLL($B,OS) $B
continue
}
}
set TTLL(ListOf,Clade) [lsort -unique $TTLL(ListOf,Clade)]
set TTLL(ListOf,JoinedClade) [join $TTLL(ListOf,Clade) " "]
set TTLL(ListOf,OX) [lsort -unique $TTLL(ListOf,OX)]
set TTLL(ListOf,OS) [lsort -unique $TTLL(ListOf,OS)]
if {$OnMemorise} { Sauve [array get TTLL] dans $Fichier }
return [TTLL $Qui $Quoi]
}
proc CMC {{Qui ""} {Quoi ""}} {
#rR Les Clades Multi Ciliés de Audrey
global CMC
regsub -all "_" $Qui " " Qui
if {[regexp -nocase "Help" $Qui]} {
lappend LeHelp "CMC stands for Clade Multi Cilia (from Audrey)"
lappend LeHelp "CMC ListOf Clade"
lappend LeHelp "CMC ListOf OX"
lappend LeHelp "CMC ListOf OS"
lappend LeHelp "CMC 9606 Clade"
lappend LeHelp "CMC Homo_sapiens Clade -> Sarcopterygii (eh oui !!! on est comme ça !!) "
lappend LeHelp "CMC 9606 Clade -> Sarcopterygii"
lappend LeHelp "CMC Sarcopterygii OX -> 7897 10090 9606 9913 9031 8364 8496 9258 13616 8469 28377"
lappend LeHelp "CMC Sarcopterygii OS -> lists the organism names"
lappend LeHelp "CMC 9606 OX -> 9606"
lappend LeHelp "CMC 9606 OS -> Homo sapiens"
lappend LeHelp "CMC Homo_sapiens OX -> 9606 (nb : with underscore _ you don't need quotes) "
lappend LeHelp "CMC Homo_sapiens OS -> Homo sapiens"
lappend LeHelp "Attention some Organims can belong to several Clades"
lappend LeHelp "CMC 12345 Clade may return several hits"
lappend LeHelp ""
lappend LeHelp " Raymond"
return [join $LeHelp "\n"]
}
set FichierCsv "/home/defosset/Stage_M2/Groupes_Blastomics_Audrey.csv"
set Fichier "/genomics/link/OI/fiches/CladesMultiCilia.txt"
if {[regexp -nocase "^ReDo_" $Qui]} {
if {[file exists $Fichier]} { file delete $Fichier }
regsub -nocase "^ReDo_" $Qui "" Qui
return [CMC $Qui $Quoi]
}
if {[info exists CMC($Qui,$Quoi)]} { return $CMC($Qui,$Quoi) }
if {[info exists CMC("EstCharge")]} { return "" }
set CMC("EstCharge") 1
set OnMemorise 0 ; #rR Attention si on mémorise il faut faire redo quand il faut
if { $OnMemorise && [file exists $Fichier]} {
array set CMC [ContenuDuFichier $Fichier]
set CMC(csv,file) $FichierCsv
return [CMC $Qui $Quoi]
}
set CMC(ListOf,Clade) {}
foreach Ligne [LesLignesDuFichier $FichierCsv] {
set A ""
set B ""
lassign [split $Ligne ";"] A B
set A [string trim $A]
set B [string trim $B]
if {[regexp -nocase {[A-Z]} $A]} {
set Clade $A
set CMC($Clade,OX) {}
set CMC($Clade,OS) {}
lappend CMC(ListOf,Clade) $Clade
continue
}
if {[regexp {^[0-9]+$} $A]} {
lappend CMC($Clade,OX) $A
lappend CMC($Clade,OS) $B
lappend CMC($A,Clade) $Clade
lappend CMC($B,Clade) $Clade
lappend CMC(ListOf,OX) $A
lappend CMC(ListOf,OS) $B
set CMC($A,OX) $A
set CMC($A,OS) $B
set CMC($B,OX) $A
set CMC($B,OS) $B
continue
}
}
set CMC(ListOf,Clade) [lsort -unique $CMC(ListOf,Clade)]
set CMC(ListOf,JoinedClade) [join $CMC(ListOf,Clade) " "]
set CMC(ListOf,OX) [lsort -unique $CMC(ListOf,OX)]
set CMC(ListOf,OS) [lsort -unique $CMC(ListOf,OS)]
if {$OnMemorise} { Sauve [array get CMC] dans $Fichier }
return [CMC $Qui $Quoi]
}
proc BestGeneId Nom {
set G [NIAG $Nom G]
if {$G!=""} { return $G }
}
proc NIAG {{Qui ""} {Quoi ""}} {
#rR Pour passer du Nom au Id Ac et GeneId et inversement
global NIAG
if {[string equal -nocase "Help" $Qui]} {
lappend LeHelp "NIAG stands for N=Nom I=UniprotId A=Accession G=Geneid"
lappend LeHelp "NIAG ListOf N"
lappend LeHelp "NIAG ListOf I"
lappend LeHelp "NIAG ListOf A"
lappend LeHelp "NIAG ListOf G"
lappend LeHelp "NIAG HSAP00001 N -> HSAP00001"
lappend LeHelp "NIAG HSAP00001 I -> 1433B_HUMAN"
lappend LeHelp "NIAG HSAP00001 A -> P31946"
lappend LeHelp "NIAG HSAP00001 G -> 7529"
lappend LeHelp "NIAG 7529 N -> HSAP00001"
lappend LeHelp "NIAG 7529 I -> ABCDEF_HUMAN"
lappend LeHelp "NIAG 7529 A -> Q12345"
lappend LeHelp "NIAG 7529 G -> 12345"
lappend LeHelp "NIAG 1433B_HUMAN N -> HSAP00001"
lappend LeHelp "NIAG 1433B_HUMAN I -> 1433B_HUMAN"
lappend LeHelp "etc."
lappend LeHelp "Attention a few UniprotIds and accession have several hits"
lappend LeHelp "NIAG ABCDEF_HUMAN Ns may return several hits (NIAG ABCDEF_HUMAN N returns only the last one)"
lappend LeHelp ""
lappend LeHelp " Raymond"
return [join $LeHelp "\n"]
}
set Fichier "[RepertoireDuGenome]/fiches/niag.txt"
if {[regexp -nocase "^ReDo_" $Qui]} {
if {[file exists $Fichier]} { file delete $Fichier }
regsub -nocase "^ReDo_" $Qui "" Qui
return [NIAG $Qui $Quoi]
}
if {[info exists NIAG($Qui,$Quoi)]} { return $NIAG($Qui,$Quoi) }
if {[info exists NIAG("EstCharge")]} { return "" }
set NIAG("EstCharge") 1
if {[file exists $Fichier]} {
array set NIAG [ContenuDuFichier $Fichier]
set NIAG(Filename,) $Fichier
return [NIAG $Qui $Quoi]
}
set NIAG(ListOf,N) {}
set NIAG(ListOf,A) {}
set NIAG(ListOf,I) {}
set NIAG(ListOf,G) {}
foreach N [ListeDesPABs] {
set I [ExtraitInfo $N "Id:"]
set A [ExtraitInfo $N "Ac:"]
set NIAG($N,N) $N
set NIAG($N,I) $I
set NIAG($N,A) $A
if {$I!=""} {
set NIAG($I,N) $N ; #rR tant pis s'il y a en a plusieurs, on prend le dernier
lappend NIAG($I,Ns) $N
}
if {$A!=""} {
set NIAG($A,N) $N ; #rR tant pis s'il y a en a plusieurs, on prend le dernier
lappend NIAG($A,Ns) $N
}
lappend NIAG(ListOf,N) $N
lappend NIAG(ListOf,I) $I
lappend NIAG(ListOf,A) $A
}
set NIAG(ListOf,I) [lsort -unique $NIAG(ListOf,I)]
set NIAG(ListOf,A) [lsort -unique $NIAG(ListOf,A)]
set NIAG(ListOf,G) [lsort -unique $NIAG(ListOf,G)]
#rR Attention là on met les Id puis les AC ... et si on trouve d'abord celui de l'Id tant mieux (car DejaVuCe)
set LesDemandes [concat $NIAG(ListOf,I) $NIAG(ListOf,A)]
set Res [IDMapping "ACC+ID" "GENEID" $LesDemandes]
if {[info exists DejaVuCe]} { unset DejaVuCe }
foreach X $LesDemandes G $Res {
scan $G "%s" G
set N $NIAG($X,N)
if {[info exists DejaVuCe($N)]} { continue }
set DejaVuCe($N) 1
if {[regexp {00$} $N]} { Espionne "$N=$X=$G=" }
if {$G==""} { continue }
if {[info exists NIAG($N,G)]} {
if { $NIAG($N,G)==$G } { continue }
FaireLire "$N=$X=$G!=$NIAG($N,G)"
}
set NIAG($N,G) $G
}
foreach N $NIAG(ListOf,N) {
if { ! [info exists NIAG($N,G)]} { continue }
set G $NIAG($N,G)
set NIAG($NIAG($N,I),G) $G
set NIAG($NIAG($N,A),G) $G
set NIAG($G,N) $N
set NIAG($G,I) $I
set NIAG($G,A) $A
lappend NIAG(ListOf,G) $G
}
set NIAG(ListOf,G) [lsort -unique $NIAG(ListOf,G)]
Sauve [array get NIAG] dans $Fichier
return [NIAG $Qui $Quoi]
}
proc ModelOrgaProject {{Qui ""} {Quoi ""}} {
global MOP
if {[regexp -nocase "Help" $Qui]} {
lappend LeHelp "ModelOrgaProject ListOf O"
lappend LeHelp "ModelOrgaProject ListOf P"
lappend LeHelp "ModelOrgaProject ListOf OP"
lappend LeHelp "ModelOrgaProject 9606 P"
lappend LeHelp "ModelOrgaProject CilioCarta O"
return [join $LeHelp "\n"]
}
if {[info exists MOP($Qui,$Quoi)]} { return $MOP($Qui,$Quoi) }
if {[info exists MOP("EstCharge")]} { return "" }
set MOP("EstCharge") 1
set LaListe {}
set LesFichierGoNoms [glob -nocomplain "/genomics/link/*/fiches/GoNoms.txt"]
foreach Fichier $LesFichierGoNoms {
set RepG [file dirname [file dirname $Fichier]]
set O [IntegerApres "NotreOX" dans [ContenuDuFichier "$RepG/beton/miniconfig"]]
if {$O==""} { continue }
set L [llength [LesLignesDuFichier $Fichier]]
Espionne "$L $O"
if {$L<987} { continue }
set P [file tail [file dirname [file dirname $Fichier]]]
lappend MOP(ListOf,OP) "$O $P"
lappend MOP(ListOf,O) $O
lappend MOP(ListOf,P) $P
lappend MOP($O,O) $O
lappend MOP($O,P) $P
set MOP($P,O) $O
set MOP($P,P) $P
}
set MOP(ListOf,O) [lsort -unique $MOP(ListOf,O)]
return [ModelOrgaProject $Qui $Quoi]
}
proc MyGOsFromModelOrga {} {
}
proc ModelOrgaGeneId {{Mod ""} {Qui ""} {Quoi ""}} {
global MOGI
set BackgroundDir "[BlastomicsDir]/data/GO/background"
if {$Mod=="GetListOfModelTaxId"} {
set LesTaxId {}
foreach File [glob -nocomplain "$BackgroundDir/*"] {
set TaxId [file tail $File]
if {[regexp {[^0-9]} $TaxId]} { continue }
lappend LesTaxId $TaxId
}
return $LesTaxId
}
if { [regexp {[^0-9]} $Mod]} { set Mod [Tax $Mod TaxId] }
if {[info exists MOGI($Mod,$Qui,$Quoi)]} { return $MOGI($Mod,$Qui,$Quoi) }
if {[info exists MOGI($Mod,EstCharge)]} { return "" }
set MOGI($Mod,EstCharge) 1
set BackgroundFile "$BackgroundDir/$Mod"
if {[FileAbsent $BackgroundFile]} { return "" }
set MOGI($Mod,BackgroundFile,) $BackgroundFile
foreach Ligne [LesLignesDuFichier $BackgroundFile] {
scan $Ligne "%s %s" A G
if { ! [regexp {^[0-9]+$} $G]} { continue }
set MOGI($Mod,$A,) $G
set MOGI($Mod,$A,A) $A
set MOGI($Mod,$A,G) $G
set MOGI($Mod,$G) $A
set MOGI($Mod,$G,A) $A
set MOGI($Mod,$G,G) $G
lappend MOGI($Mod,ListOf,A) $A
lappend MOGI($Mod,ListOf,G) $G
lappend MOGI($Mod,ListOf,AG) "$A $G"
}
return [ModelOrgaGeneId $Mod $Qui $Quoi]
}
proc TestCladeCourant {} {
Espionne [CladeCourant]
Espionne [CladeCourant Insecta]
Espionne [CladeCourant See]
Espionne [CladeCourant New]
}
proc CladeCourant {{NewValue ""} {Format ""}} {
JeMeSignale
global CladeCourant
if {$Format==""} { set Format "Name" }
if {$NewValue=="IsSet"} {
return [info exists CladeCourant]
}
if {$NewValue=="UnSet"} {
if {[info exists CladeCourant]} { unset CladeCourant }
return ""
}
if {$NewValue=="New"} {
while {$NewValue=="New"} {
if {[OnTraite "CilioCarta" "Like"]} {
set NewValue ""
break
}
set NewValue [Entre "Mammalia"]
if {[Tax $NewValue]==""} {
if {[OuiOuNon "Sorry $NewValue does not exist. Do I exit CladeCourant ?"]} { return "" }
set NewValue "New"
continue
}
}
}
if {$NewValue=="See"} {
set NewValue ""
if {[info exists CladeCourant]} { return [FaireLire $CladeCourant] }
return [FaireLire "Current Clade is not yet set"]
}
if {$NewValue!=""} {
set Value [Tax $NewValue "Name"]
set CladeCourant $Value
return [Tax $CladeCourant $Format]
}
if {[info exists CladeCourant]} { return [Tax $CladeCourant $Format] }
if {[OnTraite "CilioCarta" "Like"]} {
set CladeCourant [SelectClade "One" "UseQds"]
if {$CladeCourant==""} { set CladeCourant "Fungi" }
}
return [CladeCourant "New"]
return [CladeCourant $CladeCourant $Format]
}
proc RunDeltaDistributionForClade {K {Method ""}} {
set Touche [$K find withtag current]
set LesTags [$K gettags $Touche]
lassign $LesTags Bidon Clade
return [DeltaDistributionForClade $Clade {} {} $Method]
}
proc DeltaDistributionForClade {{Clade ""} {Seuil ""} {GetWhat ""} {Method ""} {Criteria ""}} {
if {$Clade==""} { set Clade [SelectClade] }
if {$Method==""} { set Method "Average" }
if {$Criteria==""} { set Criteria "Rank" }
set NomDeDistri [NomDe "Distri"]
set EnTest [regexp {^(ripp|scherb)$} [Login]]
set EnTest 0
if {$GetWhat==""} { set GetWhat "Show" }
if {$Seuil==""} { set Seuil 0.001 }
regsub -all " " $Clade "_" CladeUnderscore
set Echantillonage 100
set LesTaxIdsDuClade [CladeContent $Clade "UseQds" "Without,9606"]
set NbTaxId [llength $LesTaxIdsDuClade]
set Sens "increasing"
if {[regexp -nocase "Score|DeltaS" $Criteria]} { set Sens "decreasing" }
set Cadre $Clade
foreach TaxId $LesTaxIdsDuClade {
set OS [BilanCilioQds $TaxId "OS_"]
set MethLogExp [TaxoBla $Cadre $TaxId-$Method LogExp]
set MethScore [TaxoBla $Cadre $TaxId-$Method Score]
set MethRank [TaxoBla $Cadre $TaxId-$Method Rank]
set MethDeltaE [TaxoBla $Cadre $TaxId-$Method DeltaE]
set MethDeltaS [TaxoBla $Cadre $TaxId-$Method DeltaS]
set MethDeltaR [TaxoBla $Cadre $TaxId-$Method DeltaR]
Espionne "$Cadre $TaxId $Method $MethLogExp/$MethScore/$MethRank/$MethDeltaE/$MethDeltaS/$MethDeltaR"
if {$MethRank==""} { continue }
Espionne "$MethRank $OS $TaxId"
lappend LesTaxIdDuMeth(LogExp,$MethLogExp) $TaxId
lappend LesTaxIdDuMeth(Score,$MethScore) $TaxId
lappend LesTaxIdDuMeth(Rank,$MethRank) $TaxId
lappend LesTaxIdDuMeth(DeltaE,$MethDeltaE) $TaxId
lappend LesTaxIdDuMeth(DeltaS,$MethDeltaS) $TaxId
lappend LesTaxIdDuMeth(DeltaR,$MethDeltaR) $TaxId
lappend LesMeth(LogExp) $MethLogExp
lappend LesMeth(Score) $MethScore
lappend LesMeth(Rank) $MethRank
lappend LesMeth(DeltaE) $MethDeltaE
lappend LesMeth(DeltaS) $MethDeltaS
lappend LesMeth(DeltaR) $MethDeltaR
}
set LesMethCriteria [lsort -integer -$Sens $LesMeth($Criteria)]
set LesTaxIdTries {}
foreach MRank $LesMethCriteria {
foreach TaxId $LesTaxIdDuMeth($Criteria,$MRank) {
Espionne $TaxId
if { ! [info exists DejaVu($TaxId)]} {set DejaVu($TaxId) 1 ; lappend LesTaxIdTries $TaxId }
set MethLogExp [TaxoBla $Cadre $TaxId-$Method LogExp]
set MethScore [TaxoBla $Cadre $TaxId-$Method Score]
set MethRank [TaxoBla $Cadre $TaxId-$Method Rank]
set MethDeltaE [TaxoBla $Cadre $TaxId-$Method DeltaE]
set MethDeltaS [TaxoBla $Cadre $TaxId-$Method DeltaS]
set MethDeltaR [TaxoBla $Cadre $TaxId-$Method DeltaR]
if {$MethRank==""} { continue }
Espionne "[BilanCilioQds $TaxId OS_]=$TaxId=$MethLogExp=$MethScore=$MethRank=$MethDeltaE=$MethDeltaS=$MethDeltaR"
Espionne [format "%-45s %-8s %6d %6d %6d %6d %6d %6d" [BilanCilioQds $TaxId "OS_"] $TaxId $MethLogExp $MethScore $MethRank $MethDeltaE $MethDeltaS $MethDeltaR]
set LesZonards {}
#rR Il faudrait commencer par remplir avec tout ce qui est avant le premier rang pour ne pas en perdre
#rR ........... mais il vaut mieux aoir le plus petit et le plus grand ...
foreach Ranks [RankSample "ListOfList" $Criteria] {
set RankZone "[lindex $Ranks 0]-[lindex $Ranks end]"
if { ! [info exists DejaVu($RankZone)]} { set DejaVu($RankZone) 1; lappend LesRankZones $RankZone }
# set LesZonards {}
foreach Rank $Ranks {
set ZonardsDuRank [TaxoBla $Cadre $TaxId-$Criteria-$Rank ListOfNom]
if {$ZonardsDuRank!=""} { LConcat LesZonards $ZonardsDuRank }
}
set NbZonards [llength $LesZonards]
MemoZonards $NomDeDistri $TaxId-$RankZone $LesZonards set
}
}
}
MemoZonards $NomDeDistri "" "" unique
set LesBeauxTaxIdTries {}
set I 0
foreach TaxId $LesTaxIdTries {
lappend LesBeauxTaxIdTries "$TaxId [BilanCilioQds $TaxId OS_]"
set J 0
foreach RankZone $LesRankZones {
set N [llength [MemoZonards $NomDeDistri $TaxId-$RankZone]]
set T($I,$J) $N
incr J
}
incr I
}
set LeT [array get T]
set K [Medals $LesBeauxTaxIdTries $LeT $LesRankZones "" "zonard" $NomDeDistri]
set Titre "$Clade $Criteria distribution using $Method"
regsub ".canvas$" $K "" w
wm title $w $Titre
wm iconname $w $Titre
set B [BoutonneLaFenetre $w "Average Rank/DeltaR/DeltaE"]
bind $B <1> "DeltaDistributionForClade $Clade $Seuil Show Average Rank"
bind $B <2> "DeltaDistributionForClade $Clade $Seuil Show Average DeltaR"
bind $B <3> "DeltaDistributionForClade $Clade $Seuil Show Average DeltaE"
$B configure -background "Magenta"
set B [BoutonneLaFenetre $w "First Rank/DeltaR"]
bind $B "DeltaDistributionForClade $Clade $Seuil Show First Rank"
bind $B <2> "DeltaDistributionForClade $Clade $Seuil Show First DeltaR"
$B configure -background "Magenta"
return $K
}
proc ShowZonards {K NomDeDistri} {
set Touche [$K find withtag current]
set LesTags [$K gettags $Touche]
lassign $LesTags Distri I J Clade RankZone
lassign [split $Clade "_"] TaxId
set LaSortie {}
set LesNoms [MemoZonards $NomDeDistri $TaxId-$RankZone ListOfNom]
foreach Nom $LesNoms {
set Id [ExtraitInfo $Nom Id]
set Ac [ExtraitInfo $Nom Ac]
set ValiGN [ExtraitInfo $Nom ValiGN]
lappend LesGn $ValiGN
set ValiDE [ExtraitInfo $Nom ValiDE]
lappend LaSortie "$Nom\t$Id\t$Ac\t$ValiGN\t$ValiDE"
}
set F [AfficheListe "#n°[PreFixe]\n$LaSortie" "AvecFetch" "Hits with at least $Distri for $Clade"]
set GeneNames [join $LesGn ","]
set Noms [join $LesNoms ","]
set B [BoutonneLaFenetre $F "GeneOntology / Show Taxobla"]
bind $B <1> "GoGetShowFromGeneList $GeneNames"
bind $B <2> "SeeAby Taxobla \[selection get\]"
$B configure -background "Magenta"
set B [BoutonneLaFenetre $F "Homo sapiens Hits/ Info/ GOs"]
bind $B <1> "ShowHsapHits \[set PagePropre($F)\] Hits"
bind $B <2> "ShowHsapHits \[set PagePropre($F)\] Info"
bind $B <3> "ShowHsapHits \[set PagePropre($F)\] GO"
$B configure -background "Orange"
}
proc ShowHsapHits {LesNoms {Quoi ""} {RefTaxId ""}} {
JeMeSignale
set Science "CilioCarta"
if {[OnTraite OI2017 Like]} { set Science "EHomsa" }
if {[regexp "\n" $LesNoms]} {
set LesNomsLus {}
foreach Ligne [split $LesNoms "\n"] {
if {[regexp "^#" $Ligne]} { continue }
scan $Ligne "%s" NomLu
lappend LesNomsLus $NomLu
}
set LesNoms $LesNomsLus
}
if {[regexp "," $LesNoms]} { set LesNoms [split $LesNoms ","] }
if {$Quoi==""} { set Quoi "Info" }
if {$RefTaxId==""} { set RefTaxID 9606 }
set LesHsapGeneNames {}
set LesHsapInfo {}
set LesHsap {}
foreach Nom $LesNoms {
set FicTaxobla [GscopeFile $Nom "taxobla"]
if {[FileAbsent $FicTaxobla]} { continue }
foreach Ligne [LesLignesDuFichier $FicTaxobla] {
lassign [split $Ligne "\t"] PN Score TaxId Orga Info
set TaxId [string trim $TaxId]
if { ! [string equal $RefTaxID $TaxId]} { continue }
set Access [string trim [lindex [split $Info " "] 1]]
set Hsap [QuestionDeScience $Science "ret RepereBox $Access"]
if {$Hsap==""} { continue }
set HsapGN [QuestionDeScience $Science "ret BestGN $Hsap"]
set HsapDE [QuestionDeScience $Science "ret BestDE $Hsap"]
lappend LesHsapGeneNames $HsapGN
lappend LesHsapInfo "$Nom first Hsap hit: $Hsap $HsapGN $HsapDE"
lappend LesHsap $Hsap
}
}
if {$Quoi=="GO" } { return [GoGetShowFromGeneList $LesHsapGeneNames] }
if {$Quoi=="Info"} { return [AfficheListe $LesHsapInfo] }
return
}
proc CladesDistribution {{Method ""} {Criteria ""}} {
if {$Criteria==""} { set Criteria "Rank" }
if {$Method==""} { set Method "Average" }
set NomDeClaDistri [NomDe "ClaDistri"]
foreach Clade [SelectClade "Multiple" "UseQds"] {
set Cadre $Clade
set MethCrit [TaxoBla $Cadre $Method $Criteria]
if {$MethCrit==""} { continue }
lappend LesCladeDuMethCrit($MethCrit) $Clade
lappend LesMethCrit $MethCrit
Espionne "$Clade $MethCrit"
}
set Sens "increasing"
if {[regexp -nocase "Score" $Criteria]} { set Sens "decreasing" }
set LesMethCrit [lsort -integer -$Sens [set LesMethCrit]]
set LesCladesTries {}
foreach MCrit $LesMethCrit {
Espionne "MCrit $MCrit"
foreach Clade [set LesCladeDuMethCrit($MCrit)] {
set Cadre $Clade
if { ! [info exists DejaVu($Clade)]} {set DejaVu($Clade) 1 ; lappend LesCladesTries $Clade }
set MethCrit [TaxoBla $Cadre $Method $Criteria]
Espionne [format "%-18s %6d" $Clade $MethCrit]
foreach Crits [RankSample "ListOfList" $Criteria] {
Espionne "$Crits"
set CritZone "[lindex $Crits 0]-[lindex $Crits end]"
if { ! [info exists DejaVu($CritZone)]} { set DejaVu($CritZone) 1; lappend LesCritZones $CritZone }
set LesZonards {}
foreach Crit $Crits {
set ZonardsDuCrit [TaxoBla $Cadre ${Method}$Criteria-$Crit ListOfNom]
if {$ZonardsDuCrit!=""} { LConcat LesZonards $ZonardsDuCrit }
}
set NbZonards [llength $LesZonards]
MemoZonards $NomDeClaDistri $Clade-$CritZone $LesZonards set
}
}
}
MemoZonards $NomDeClaDistri "" "" unique
set I 0
foreach Clade $LesCladesTries {
set J 0
foreach CritZone $LesCritZones {
set N [llength [MemoZonards $NomDeClaDistri $Clade-$CritZone]]
set T($I,$J) $N
incr J
}
incr I
}
set LeT [array get T]
set K [Medals $LesCladesTries $LeT $LesCritZones "" "zonard" $NomDeClaDistri]
regsub ".canvas" $K "" w
set Titre "CladesDistribution $Method $Criteria"
wm title $w $Titre
wm iconname $w $Titre
set B [BoutonneLaFenetre $w "Clades Rank Distribution Average/ First"]
bind $B <1> "CladesDistribution Average"
bind $B <2> "CladesDistribution First"
$B configure -background "Magenta"
set B [BoutonneLaFenetre $w "Clades Score Distribution Average/ First"]
bind <1> "CladesDistribution Average Score"
bind $B <2> "CladesDistribution First Score"
$B configure -background "Magenta"
set B [BoutonneLaFenetre $w "Clades Expect Distribution Average/ First"]
bind $B <1> "CladesDistribution Average LogExp"
bind $B <2> "CladesDistribution First LogExp"
$B configure -background "Magenta"
return $K
}
proc MemoZonards {{Qui ""} {Quoi ""} {Valeur ""} {Action ""}} {
global MemoZonards
if {$Action==""} { set Action "get" }
if {$Action=="get"} {
if {[info exists MemoZonards($Qui,$Quoi)] } { return $MemoZonards($Qui,$Quoi) }
return ""
}
if {$Action=="Reset"} { if {[info exists MemoZonards($Qui,$Quoi)] } { unset MemoZonards($Qui,$Quoi) } ; return "" }
if {$Action=="set"} { set MemoZonards($Qui,$Quoi) $Valeur ; return $MemoZonards($Qui,$Quoi) }
if {$Action=="append"} { lappend MemoZonards($Qui,$Quoi) $Valeur ; return $MemoZonards($Qui,$Quoi) }
if {$Action=="unique"} {
foreach {K V} [array get MemoZonards] {
set MemoZonards($K) [ListeSansDoublon $V]
}
}
return ""
}
proc RankSample {{What ""} {Criteria ""}} {
set Increment 1
if {$Criteria==""} { set Criteria "Rank" }
if {$Criteria=="Rank"} { set RankSample [list 1 2 3 4 5 7 8 9 10 15 20 25 30 35 40 45 50 55 60 70 75 80 90 101] }
if {$Criteria=="DeltaR"} { set RankSample [concat [list -100] [NombresEntre -75 50 5] [list 100]] }
if {$Criteria=="DeltaE"} { set RankSample [concat [list -250] [NombresEntre -220 50 5] [list -250]] }
if {$Criteria=="DeltaS"} { set RankSample [concat [list 9000] [NombresEntre 3000 0 -100] ] ; set Increment -1 }
if {$Criteria=="Score"} { set RankSample [concat [list 9000] [NombresEntre 3000 0 -100] [list -3000]] ; set Increment -1 }
if {$Criteria=="LogExp"} { set RankSample [concat [list -250] [NombresEntre -220 0 5] ] }
set RankSampleDeb {}
set RankSampleFin {}
foreach D [lrange $RankSample 0 end-1] F [lrange $RankSample 1 end] {
incr F -1
lappend RankSampleDeb $D
lappend RankSampleFin $F
}
foreach D $RankSampleDeb F $RankSampleFin {
lappend RankSampleLimits "$D-$F"
}
if {$What=="List"} { return $RankSample }
if {$What=="ListOfList"} {
set LL {}
foreach D $RankSampleDeb F $RankSampleFin {
lappend LL [NombresEntre $D $F $Increment]
}
return $LL
}
}
proc OlymCladeHelp {{GetWhat ""}} {
set Texte "
OlymClade permet de comparer et de voir les distributions des positions du premier hit de chaque organisme dans les blastp
Avant tout il faut bien retenir que
1/ l'on part de taxobla qui contient dans l'ordre du blast les positions du premier hit de chaque organisme
chaque ligne contient séparés par tabulation (et des blancs en fin de valeur, mais a partir de SuiteInfo il n'y a plus de tab)
expect score taxid OC Suite info
1e-73 234 88036 Selaginella moellendorffii (strand ... D8RPE7_SELML D8RPE7 Selaginella moellendorffii Ubiquinol oxidase GN=SELMODRAFT_232012 OS=Selaginella_moellendorffii TAXID=88036 BANK=tr OX=88036 Length = 302
2/
"
if {$GetWhat=="Show"} { return [Affiche $Texte] }
return $Texte
}
proc NiceRank {AbsRank MaxPossible} {
set NiceRank(1) 1
set NiceRank(2) 2
set NiceRank(3) 3
set NiceRank(4) 4
set NiceRank(5) 5
set NiceRank(6) 6
set NiceRank(7) 7
set NiceRank(8) 8
set NiceRank(9) 9
if {[info exists NiceRank(AbsRank)]} { return $NiceRank(AbsRank) }
set Rank [expr int(($AbsRank-9)*100/$MaxPossible) + 10]
return $Rank
}
proc TaxoBla {{Cadre ""} {Qui ""} {Quoi ""}} {
#rR TaxoBla stocke tout ce qu'il peut pour tous les CladeDistrbution ci-dessus
#rR En fait Cadre est censé être du style Clade_0.001_FirstOnly_UseExpect
#rR On peut donc faire l'étude d'un clade dans plusieurs cadres ;)
#rR attention Expect est le vrai expect ... LogExp = log10($Expect)
#rR attention Expect est le vrai expect ... LogExp = log10($Expect)
#rR attention Expect est le vrai expect ... LogExp = log10($Expect)
#rR attention Expect est le vrai expect ... LogExp = log10($Expect)
#rR TaxoBla lit les fichiers taxobla où ne figure qu'une fois chaque organisme...
#rR FirstOnly concerne le First d'un Clade ...
#rR Petite remarque : les Rank et LogExpect sont croissants, les Score sont décroissants
#rR DeltaE va de -250 à +250
#rR DeltaS de 3000 à -3000
#rR DeltaR de -100 à +100
global TaxoBla
if {[info exists TaxoBla($Cadre,$Qui,$Quoi)]} { return $TaxoBla($Cadre,$Qui,$Quoi) }
if {[info exists TaxoBla($Cadre,"EstCharge")]} { return "" }
if {[regexp {^New_(.+)} $Cadre Match CadreLu]} {
foreach Name [array names TaxoBla -glob "$CadreLu,*"] {
unset TaxoBla($Name)
}
set Cadre $CadreLu
set FichierTaxoBla [Fiches "taxobla_$Cadre.txt"]
if {[file exists $FichierTaxoBla]} { file delete $FichierTaxoBla }
}
set TaxoBla($Cadre,"EstCharge") 1
set Clade ""
set Seuil ""
set SelectMethod ""
set UseExpect ""
lassign [split $Cadre "_"] Clade Seuil SelectMethod UseExpect
if {[OnTraite CilioCarta Like]} {
set LesTaxId [CladeContent $Clade "UseQds" "Without,[NotreOX]"]
} elseif {[OnTraite OI2017 Like]} {
set LesTaxId [CladeContentWithinOi2017 $Clade]
} else {
FaireLire "Désolé. Il faut être CilioCarta Like ou OI2017 Like ..."
}
set LesOS {}
foreach TaxId $LesTaxId {
set OS [join [Tax $TaxId Name] "_"]
lappend LesOS $OS
}
if {$Seuil==""} { set Seuil 0.001 }
if {$SelectMethod==""} { set SelectMethod "FirstOnly" }
if {$UseExpect==""} { set USeExpect "UseExpect" }
set TaxoBla($Cadre,Cadre,) $Cadre
set TaxoBla($Cadre,ListOf,TaxId) $LesTaxId
set TaxoBla($Cadre,ListOf,OS) $LesOS
set TaxoBla($Cadre,Seuil,) $Seuil
set TaxoBla($Cadre,SelectMethod,) $SelectMethod
set TaxoBla($Cadre,UseExpect,) $UseExpect
set TaxoBla($Cadre,ListOf,DeltaE) {}
set TaxoBla($Cadre,ListOf,DeltaS) {}
set TaxoBla($Cadre,ListOf,DeltaR) {}
set FichierTaxoBla [Fiches "taxobla_$Cadre.txt"]
set TaxoBla($Cadre,file,) $FichierTaxoBla
#rR Attention ici on lit le fichier memorisé ... à effacer s'il faut le refaire
if {[file exists $FichierTaxoBla]} {
array set TaxoBla [LesLignesDuFichier $FichierTaxoBla]
return [TaxoBla $Cadre $Qui $Quoi]
}
if {$LesTaxId=={}} { return [TaxoBla $Cadre $Qui $Quoi] }
foreach TaxId $LesTaxId {
set TaxoBla($Cadre,$TaxId-Sum,LogExp) 0
set TaxoBla($Cadre,$TaxId-Sum,Score) 0
set TaxoBla($Cadre,$TaxId-Sum,Rank) 0
set TaxoBla($Cadre,$TaxId-Sum,DeltaE) 0
set TaxoBla($Cadre,$TaxId-Sum,DeltaS) 0
set TaxoBla($Cadre,$TaxId-Sum,DeltaR) 0
}
set SumAllLogExp 0
set SumAllScore 0
set SumAllRank 0
set SumAllFirstLogExp 0
set SumAllFirstScore 0
set SumAllFirstRank 0
set SumAllDeltaE 0
set SumAllDeltaS 0
set SumAllDeltaR 0
set NbNom 0
foreach Nom [ListeDesPABs] {
set TaxoBla($Cadre,$Nom,ListOfTaxId) {}
set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]]
if {$LesOrgaTrie=={}} { continue }
set LesChoisis {}
set FirstTaxId ""
set Ieme 0
set NbHits 0
foreach Ligne $LesOrgaTrie {
incr Ieme
#rR je rappelle que taxobla ne contient qu'une fois chaque organisme
lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
set TaxId [string trim $TaxId]
if {[lsearch $LesTaxId $TaxId]<0} { continue }
if {$Expect==0.0} { set Expect 1.0e-250 }
#if {$Expect >1.0} { set Expect 1.0 }
set OS [string trim $OS]
set Reste [string trim $Reste]
set Expect [string trim $Expect]
set Score [expr round([string trim $Score])]
set BonSeuil $Seuil
if {[regexp -nocase "^e" $Seuil]} { set BonSeuil "1.0$Seuil" }
if {$Expect > $BonSeuil} { break }
incr NbHits
if { ! [info exists DejaVu($Nom)]} { set DejaVu($Nom) 1 ; lappend TaxoBla($Cadre,ListOf,Nom) $Nom }
set LogExp [expr round(log10($Expect))] ;#rR on passe en log !!!!!!!!!!!!!!!!!
set AbsRank $Ieme
lappend LesLogExps $LogExp
lappend LesScores $Score
lappend TaxoBla($Cadre,$Nom,ListOfTaxId) $TaxId
set TaxoBla($Cadre,$Nom-$TaxId,Expect) $Expect
set TaxoBla($Cadre,$Nom-$TaxId,LogExp) $LogExp
set TaxoBla($Cadre,$Nom-$TaxId,Score) $Score
set TaxoBla($Cadre,$Nom-$TaxId,AbsRank) $AbsRank
if {$FirstTaxId==""} {
set FirstTaxId $TaxId
set FirstLogExp $LogExp
set FirstScore $Score
set FirstAbsRank $AbsRank
set TaxoBla($Cadre,$Nom-First,TaxId) $TaxId
set TaxoBla($Cadre,$Nom-First,LogExp) $LogExp
set TaxoBla($Cadre,$Nom-First,Score) $Score
set TaxoBla($Cadre,$Nom-First,AbsRank) $AbsRank
lappend TaxoBla($Cadre,FirstTaxId-$TaxId,ListOfNom) $Nom
set TaxoBla($Cadre,$TaxId-First,LogExp) $LogExp
set TaxoBla($Cadre,$TaxId-First,Score) $Score
}
set TaxoBla($Cadre,$TaxId-Sum,LogExp) [expr $TaxoBla($Cadre,$TaxId-Sum,LogExp) + $LogExp]
set TaxoBla($Cadre,$TaxId-Sum,Score) [expr $TaxoBla($Cadre,$TaxId-Sum,Score) + $Score]
lappend TaxoBla($Cadre,$TaxId,ListOfNom) $Nom
}
set NbHitsInBlast $Ieme
set TaxoBla($Cadre,$Nom,NbHits) $NbHits
if {$NbHits==0} { continue}
incr NbNom
set SumLogExp 0
set SumScore 0
set SumRank 0
foreach TaxId $TaxoBla($Cadre,$Nom,ListOfTaxId) {
#set Rank [expr $TaxoBla($Cadre,$Nom-$TaxId,AbsRank)*100/$NbHitsInBlast]
set Rank [NiceRank $TaxoBla($Cadre,$Nom-$TaxId,AbsRank) $NbHitsInBlast]
set TaxoBla($Cadre,$Nom-$TaxId,Rank) $Rank
if {$TaxId==$FirstTaxId} {
set TaxoBla($Cadre,$Nom-First,Rank) $Rank
set TaxoBla($Cadre,$TaxId-First,Rank) $Rank
set FirstRank $Rank
}
set SumLogExp [expr $SumLogExp + $TaxoBla($Cadre,$Nom-$TaxId,LogExp)]
set SumScore [expr $SumScore + $TaxoBla($Cadre,$Nom-$TaxId,Score)]
set SumRank [expr $SumRank + $TaxoBla($Cadre,$Nom-$TaxId,Rank)]
}
set AverageLogExp [expr round($SumLogExp / $NbHits)]
set AverageScore [expr round($SumScore / $NbHits)]
set AverageRank [expr max(1,round($SumRank / $NbHits))] ;#rR j'ai mis 1 minimum
#set AverageRank [expr max(1,[NiceRank $SumRank $NbHits])] ;#rR j'ai mis 1 minimum
set TaxoBla($Cadre,$Nom-Average,LogExp) $AverageLogExp
set TaxoBla($Cadre,$Nom-Average,Score) $AverageScore
set TaxoBla($Cadre,$Nom-Average,Rank) $AverageRank
lappend TaxoBla($Cadre,AverageLogExp-$AverageLogExp,ListOfNom) $Nom
lappend TaxoBla($Cadre,AverageScore-$AverageScore,ListOfNom) $Nom
lappend TaxoBla($Cadre,AverageRank-$AverageRank,ListOfNom) $Nom
lappend TaxoBla($Cadre,FirstLogExp-$FirstLogExp,ListOfNom) $Nom
lappend TaxoBla($Cadre,FirstScore-$FirstScore,ListOfNom) $Nom
lappend TaxoBla($Cadre,FirstRank-$FirstRank,ListOfNom) $Nom
set SumDeltaE 0
set SumDeltaS 0
set SumDeltaR 0
foreach TaxId $TaxoBla($Cadre,$Nom,ListOfTaxId) {
set DeltaE [expr round($TaxoBla($Cadre,$Nom-$TaxId,LogExp) - $TaxoBla($Cadre,$Nom-Average,LogExp))]
set DeltaS [expr round($TaxoBla($Cadre,$Nom-$TaxId,Score) - $TaxoBla($Cadre,$Nom-Average,Score))]
set DeltaR [expr round($TaxoBla($Cadre,$Nom-$TaxId,Rank) - $TaxoBla($Cadre,$Nom-Average,Rank))]
set TaxoBla($Cadre,$TaxId-First,DeltaE) $DeltaE
set TaxoBla($Cadre,$TaxId-First,DeltaS) $DeltaS
set TaxoBla($Cadre,$TaxId-First,DeltaR) $DeltaR
incr SumDeltaE $DeltaE
incr SumDeltaS $DeltaS
incr SumDeltaR $DeltaR
set TaxoBla($Cadre,$Nom-$TaxId,DeltaE) $DeltaE
set TaxoBla($Cadre,$Nom-$TaxId,DeltaS) $DeltaS
set TaxoBla($Cadre,$Nom-$TaxId,DeltaR) $DeltaR
lappend TaxoBla($Cadre,DeltaE-$DeltaE,ListOfNom) $Nom
lappend TaxoBla($Cadre,DeltaS-$DeltaS,ListOfNom) $Nom
lappend TaxoBla($Cadre,DeltaR-$DeltaR,ListOfNom) $Nom
lappend TaxoBla($Cadre,ListOf,DeltaE) $DeltaE
lappend TaxoBla($Cadre,ListOf,DeltaS) $DeltaS
lappend TaxoBla($Cadre,ListOf,DeltaR) $DeltaR
set LogExp $TaxoBla($Cadre,$Nom-$TaxId,LogExp)
set Score $TaxoBla($Cadre,$Nom-$TaxId,Score)
set Rank $TaxoBla($Cadre,$Nom-$TaxId,Rank)
lappend TaxoBla($Cadre,ListOf,LogExp) $LogExp
lappend TaxoBla($Cadre,ListOf,Score) $Score
lappend TaxoBla($Cadre,ListOf,Rank) $Rank
lappend TaxoBla($Cadre,$TaxId-LogExp-$LogExp,ListOfNom) $Nom
lappend TaxoBla($Cadre,$TaxId-Score-$Score,ListOfNom) $Nom
lappend TaxoBla($Cadre,$TaxId-Rank-$Rank,ListOfNom) $Nom
lappend TaxoBla($Cadre,$TaxId-DeltaE-$DeltaE,ListOfNom) $Nom
lappend TaxoBla($Cadre,$TaxId-DeltaS-$DeltaS,ListOfNom) $Nom
lappend TaxoBla($Cadre,$TaxId-DeltaR-$DeltaR,ListOfNom) $Nom
set TaxoBla($Cadre,$TaxId-Sum,Rank) [expr $TaxoBla($Cadre,$TaxId-Sum,Rank) + $Rank]
set TaxoBla($Cadre,$TaxId-Sum,DeltaE) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaE) + $DeltaE]
set TaxoBla($Cadre,$TaxId-Sum,DeltaS) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaS) + $DeltaS]
set TaxoBla($Cadre,$TaxId-Sum,DeltaR) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaR) + $DeltaR]
}
set TaxoBla($Cadre,$Nom-Average,DeltaE) [expr round($SumDeltaE / $NbHits)]
set TaxoBla($Cadre,$Nom-Average,DeltaS) [expr round($SumDeltaS / $NbHits)]
set TaxoBla($Cadre,$Nom-Average,DeltaR) [expr round($SumDeltaR / $NbHits)]
set SumAllLogExp [expr $SumAllLogExp + $TaxoBla($Cadre,$Nom-Average,LogExp)]
set SumAllScore [expr $SumAllScore + $TaxoBla($Cadre,$Nom-Average,Score)]
set SumAllRank [expr $SumAllRank + $TaxoBla($Cadre,$Nom-Average,Rank)]
set SumAllDeltaE [expr $SumAllDeltaE + $TaxoBla($Cadre,$Nom-Average,DeltaE)]
set SumAllDeltaS [expr $SumAllDeltaS + $TaxoBla($Cadre,$Nom-Average,DeltaS)]
set SumAllDeltaR [expr $SumAllDeltaR + $TaxoBla($Cadre,$Nom-Average,DeltaR)]
set SumAllFirstLogExp [expr $SumAllFirstLogExp + $TaxoBla($Cadre,$Nom-First,LogExp)]
set SumAllFirstScore [expr $SumAllFirstScore + $TaxoBla($Cadre,$Nom-First,Score)]
set SumAllFirstRank [expr $SumAllFirstRank + $TaxoBla($Cadre,$Nom-First,Rank)]
} ;#rR fin de la boucle sur Nom
set TaxoBla($Cadre,ListOf,LogExp) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,LogExp)]
set TaxoBla($Cadre,ListOf,Score) [lsort -unique -integer -decreasing $TaxoBla($Cadre,ListOf,Score)]
set TaxoBla($Cadre,ListOf,Rank) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,Rank)]
set TaxoBla($Cadre,ListOf,DeltaE) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,DeltaE)]
set TaxoBla($Cadre,ListOf,DeltaS) [lsort -unique -integer -decreasing $TaxoBla($Cadre,ListOf,DeltaS)]
set TaxoBla($Cadre,ListOf,DeltaR) [lsort -unique -integer -increasing $TaxoBla($Cadre,ListOf,DeltaR)]
set TaxoBla($Cadre,Average,LogExp) [expr $SumAllLogExp/$NbNom]
set TaxoBla($Cadre,Average,Score) [expr $SumAllScore/$NbNom]
set TaxoBla($Cadre,Average,Rank) [expr $SumAllRank/$NbNom]
set TaxoBla($Cadre,Average,DeltaE) [expr $SumAllDeltaE/$NbNom]
set TaxoBla($Cadre,Average,DeltaS) [expr $SumAllDeltaS/$NbNom]
set TaxoBla($Cadre,Average,DeltaR) [expr $SumAllDeltaR/$NbNom]
set TaxoBla($Cadre,First,LogExp) [expr $SumAllFirstLogExp/$NbNom]
set TaxoBla($Cadre,First,Score) [expr $SumAllFirstScore/$NbNom]
set TaxoBla($Cadre,First,Rank) [expr $SumAllFirstRank/$NbNom]
foreach TaxId $LesTaxId {
if { ! [info exists TaxoBla($Cadre,$TaxId,ListOfNom)]} { continue }
set N [llength $TaxoBla($Cadre,$TaxId,ListOfNom)]
set TaxoBla($Cadre,$TaxId-Average,LogExp) [expr $TaxoBla($Cadre,$TaxId-Sum,LogExp)/$N]
set TaxoBla($Cadre,$TaxId-Average,Score) [expr $TaxoBla($Cadre,$TaxId-Sum,Score)/$N]
set TaxoBla($Cadre,$TaxId-Average,Rank) [expr $TaxoBla($Cadre,$TaxId-Sum,Rank)/$N] ; set TaxoBla($Cadre,$TaxId-Average,Rank) [expr max(1,$TaxoBla($Cadre,$TaxId-Average,Rank))]
set TaxoBla($Cadre,$TaxId-Average,DeltaE) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaE)/$N]
set TaxoBla($Cadre,$TaxId-Average,DeltaS) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaS)/$N]
set TaxoBla($Cadre,$TaxId-Average,DeltaR) [expr $TaxoBla($Cadre,$TaxId-Sum,DeltaR)/$N]
}
SauveLesLignes [array get TaxoBla "$Cadre,*"] dans $FichierTaxoBla
return [TaxoBla $Cadre $Qui $Quoi]
}
proc MemOlym {{Qui ""} {Quoi ""} {Valeur ""}} {
global MemOlym
set Qui [string trim $Qui]
set Quoi [string trim $Quoi]
if {$Qui=="Reset"} {
if {[info exists MemOlym]} { unset MemOlym }
return ""
}
if {$Valeur==""} {
if {[info exists MemOlym($Qui,$Quoi)]} { return $MemOlym($Qui,$Quoi) }
if {[info exists MemOlym("EstCHarge")]} { return "" }
}
set MemOlym("EstCHarge") 1
lappend MemOlym($Qui,$Quoi) $Valeur
return [MemOlym $Qui $Quoi]
}
proc LesHitsAvecDelta {Nom LesOrganismesInteressants {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {
if {$UseExpect==""} { set UseExpect "UseExpect" }
set UseExp [string equal -nocase "UseExpect" $UseExpect]
if {$SelectMethod==""} { set SelectMethod "FirstOnly" }
if {$GetWhat==""} { set GetWhat "Show" }
if {$Seuil==""} { set Seuil 99999 }
if {[regexp -nocase "Best" $SelectMethod]} { set SelectMethode "BestOnly" }
if {[regexp -nocase "First" $SelectMethod]} { set SelectMethode "FirstOnly" }
if {[regexp -nocase "Ave" $SelectMethod]} { set SelectMethode "AboveAverage" }
if {$LesOrganismesInteressants=={}} { return {} }
set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]]
if {$LesOrgaTrie=={}} { return {} }
set LesChoisis {}
set PremierTaxId ""
foreach Ligne $LesOrgaTrie {
#rR je rappelle que taxobla ne contient qu'une fois chaque organisme
lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
if {$Expect==0.0} { set Expect 1.0e-250 }
# if {$Expect >1.0} { set Expect 1.0 }
set TaxId [string trim $TaxId]
set OS [string trim $OS]
set Reste [string trim $Reste]
if {[lsearch $LesOrganismesInteressants $TaxId]<0} { continue }
if {$PremierTaxId==""} { set PremierTaxId $TaxId }
set Expect [string trim $Expect]
set Score [string trim $Score]
if {$Expect > $Seuil} { break }
lappend LesExpects $Expect
lappend LesScores $Score
lappend LesChoisis "$Expect\t$Score\t$TaxId\t$OS\t$Reste"
}
if {$LesChoisis=={}} { return "" }
if {$UseExp} {
set LesValeurs $LesExpects
set LesValeurs [StatisticsFromList $LesValeurs Iterate log10] ;#rR passage en log
} else {
set LesValeurs $LesScores
}
lassign [StatisticsFromList $LesValeurs] MoyenneBidon EcartType Min Max Somme NbValeurs
set Moyenne [expr $Somme/[llength $LesOrganismesInteressants]]
set LaSortie {}
foreach Choisi $LesChoisis {
lassign [split $Choisi "\t"] Expect Score TaxId
if {$UseExp} {
set Valeur $Expect
set Valeur [expr log10($Valeur)] ;#rR passage en log
} else {
set Valeur $Score
}
set Delta [expr $Valeur-$Moyenne]
set HitAvecDelta "$Delta\t$Choisi"
if {$SelectMethod=="FirstOnly" && $TaxId!=$PremierTaxId} { continue } ;#rR la on choisit de ne garder que le meilleur dans l'ordre du blast
if {$UseExp} {
if {$SelectMethod=="BestOnly" && $Delta > -10} { continue }
if {$SelectMethod=="AboveAverage" && $Delta > 0} { continue }
} else {
if {$SelectMethod=="BestOnly" && $Delta > 100} { continue }
if {$SelectMethod=="AboveAverage" && $Delta > 0} { continue }
}
lappend LaSortie $HitAvecDelta
}
if {[regexp "/" $GetWhat] || [string equal -nocase "Save" $GetWhat]} {
set FichierDeltas $GetWhat
if {[string equal -nocase "Save" $GetWhat]} { set FichierDeltas [GscopeFile $Nom delta] }
return [SauveLesLignes $LaSortie dans $FichierDeltas]
}
if {[string equal -nocase "GetList" $GetWhat]} { return $LaSortie }
if {[string equal -nocase "GetText" $GetWhat]} { return [join $LaSortie "\n"] }
return [AfficheListe $LaSortie]
}
proc HistoDelta {{Clade ""} {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {
if {$Clade==""} { set Clade [SelectClade] }
set EnTest [regexp {^(ripp|scherb)$} [Login]]
# set EnTest 0
if {$UseExpect==""} { set UseExpect "UseScore" }
set UseExp [string equal -nocase "UseExpect" $UseExpect]
if {$GetWhat==""} { set GetWhat "Show" }
if {$Seuil==""} { set Seuil 99999 }
if {$Clade==""} { set Clade [ReferenceClade] }
regsub -all " " $Clade "_" CladeUnderscore
set Echantillonage 100
if {[OnTraite CiloCarta Like]} {
set LesTaxIdsInteressants [QuestionDeScience CilioCarta "ret CladeContent $Clade"]
} elseif {[OnTraite OI2017 Like]} {
set LesTaxIdsInteressants [QuestionDeScience OI "ret CladeContentWithinOi2017 $Clade"]
} else {
FaireLire "Désolé. Il faut êrte CiloCarta LIke ou OI2017 Like"
}
if {[set i [lsearch $LesTaxIdsInteressants 9606]]>=0} {
set LesTaxIdsInteressants [lreplace $LesTaxIdsInteressants $i $i]
}
set NbTaxId [llength $LesTaxIdsInteressants]
foreach TaxId $LesTaxIdsInteressants {
set SommeDesDeltasPour($TaxId) 0.0
set NbDeltasPour($TaxId) 0
}
set LesMeilleurs {}
set NbNom 0
foreach Nom [ListeDesPABs] {
if {0 && $EnTest && $Nom > "HSAP20193"} { break }
set LesHitsAvecDelta [LesHitsAvecDelta $Nom $LesTaxIdsInteressants $Seuil "GetList" $SelectMethod $UseExpect]
if {1 && $NbNom%1000==0} { Espionne $Nom ; EspionneL $LesHitsAvecDelta }
if {$LesHitsAvecDelta=={}} { continue }
incr NbNom
foreach HitAvecDelta $LesHitsAvecDelta {
lassign $HitAvecDelta Delta Expect Score TaxId OS Reste
regsub -all "\t" $OS " " OS
MemOlym $Nom-$TaxId Delta $Delta
MemOlym $Nom-$TaxId Info $HitAvecDelta
set SommeDesDeltasPour($TaxId) [expr $SommeDesDeltasPour($TaxId)+$Delta] ;#rR attention ici on additionne des carottes et des navets !!!!!!!! car Nom différents
set InfoDu($TaxId) "$OS\t$Reste"
incr NbDeltasPour($TaxId)
lappend LesDeltasDe($TaxId) $Delta
lappend LesNomsDe($TaxId,$Delta) $Nom
MemOlym $TaxId-$Delta ListOfNom $Nom
MemoDelta $TaxId $Delta $Nom
set BeauDelta [format "%6.0f" $Delta]
if {$Delta!=$BeauDelta} { MemOlym $TaxId-$BeauDelta ListOfNom $Nom ; MemoDelta $TaxId $Delta $Nom}
}
}
foreach TaxId $LesTaxIdsInteressants {
if {$NbDeltasPour($TaxId)==0} {
set Moyenne -999
} else {
set Moyenne [expr $SommeDesDeltasPour($TaxId)/$NbDeltasPour($TaxId)]
}
set MoyenneDesDeltasPour($TaxId) $Moyenne
lappend LesMoyennesDesDeltas $Moyenne
lappend LesTaxIdsDeLaMoyenneDesDeltas($Moyenne) $TaxId
}
if {$UseExp} {
set LesMoyennesDesDeltas [lsort -unique -real $LesMoyennesDesDeltas]
} else {
set LesMoyennesDesDeltas [lsort -decreasing -unique -real $LesMoyennesDesDeltas]
}
set LaSortie [list "# TailleP NombreDeDelta Moyenne TaxId Nom_de_l'espece "]
foreach Moyenne $LesMoyennesDesDeltas {
foreach TaxId $LesTaxIdsDeLaMoyenneDesDeltas($Moyenne) {
set BelleMoyenne [format "%6.0f" $Moyenne]
if { ! [info exists InfoDu($TaxId)]} { continue }
lappend LaSortie "[TailleProteome $TaxId]\t$NbDeltasPour($TaxId)\t$BelleMoyenne\t$TaxId\t$InfoDu($TaxId)\t$Moyenne"
}
}
EspionneL $LaSortie
set AvecHisto 0
if {$AvecHisto} {
set LargeurMax 4000
set HauteurMax 5000
set Largeur 3000
set Hauteur 2000
set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur]
global BornesDuGraphe ; set BornesDuGraphe($K) [list -250 0 250 400]
}
set MinAllDelta 9999999
set MaxAllDelta -9999999
set IemeTaxId -1
foreach TaxId $LesTaxIdsInteressants {
if { ! [info exists LesDeltasDe($TaxId)]} { continue }
set OS [Tax $TaxId Name]
regsub -all " " $OS "_" OSUnderscore
incr IemeTaxId
set MinAllDelta 9999999
set MaxAllDelta -9999999
foreach Delta $LesDeltasDe($TaxId) {
set MinAllDelta [Mini $Delta $MinAllDelta]
set MaxAllDelta [Maxi $Delta $MaxAllDelta]
}
}
set IntAllDelta [expr ($MaxAllDelta - $MinAllDelta)/$Echantillonage]
set IemeTaxId -1
foreach TaxId $LesTaxIdsInteressants {
if { ! [info exists LesDeltasDe($TaxId)]} { continue }
set OS [Tax $TaxId Name]
regsub -all " " $OS "_" OSUnderscore
incr IemeTaxId
if {[info exists Cumul]} { unset Cumul }
set MinDelta 9999999
set MaxDelta -9999999
foreach Delta $LesDeltasDe($TaxId) {
set MinDelta [Mini $Delta $MinDelta]
set MaxDelta [Maxi $Delta $MaxDelta]
}
set IntDelta [expr ($MaxDelta - $MinDelta)/$Echantillonage]
set MinDeltaDe($TaxId) $MinDelta
set MaxDeltaDe($TaxId) $MaxDelta
set IntervalDeltaDe($TaxId) $IntDelta
set MinCase 9999
set MaxCase -9999
foreach Delta $LesDeltasDe($TaxId) {
if {$IntDelta<0.0000001} {
set Case 0
} else {
#set Case [expr round(($Delta - $MinDelta)/$IntDelta)]
set Case [expr round(($Delta - $MinAllDelta)/$IntAllDelta)]
}
set MinCase [Mini $MinCase $Case]
set MaxCase [Maxi $MaxCase $Case]
if { ! [info exists Cumul($Case)]} { set Cumul($Case) 0 }
incr Cumul($Case)
set Tag($Case) $Delta
foreach Nom [MemoDelta $TaxId $Delta] {
set BeauDelta [format "%6.0f" $Delta]
set BelleMoyenne [format "%6.0f" $Moyenne]
MemoInfo $TaxId $Case "$Nom [string trim $BeauDelta] $BelleMoyenne"
}
}
set LesX {}
set LesY {}
set LesTags {}
set LaDistrib [list "#Delta Nb Case TaxId OS Reference_Clade"]
set LesBornesDeCases [NombresEntre $MinCase $MaxCase]
if { ! $UseExp} {
set LesBornesDeCases [lreverse $LesBornesDeCases]
}
foreach Case $LesBornesDeCases {
if { ! [info exists Cumul($Case)]} { set Cumul($Case) 0 }
if {$Cumul($Case)==0} { continue }
if { ! [info exists Tag($Case)]} { set Tag($Case) "0.0" }
if { ! [info exists DeltaDeLaCase($Case)]} { set DeltaDeLaCase($Case) "0.0" }
set X [expr $MinAllDelta + $Case*$IntAllDelta]
lappend LesX $X
lappend LesY $Cumul($Case)
lappend LesTags "[format %6.0f $X]:$Cumul($Case) $OS"
lappend LaDistrib "[format %6.0f $X]\t$Cumul($Case)\t$Case\tTaxId:$TaxId\tOS:$OSUnderscore\tReferenceClade:$CladeUnderscore"
}
MemoCase $TaxId LaDistrib $LaDistrib
if {$AvecHisto} {
set Couleur [Nuance [expr 1.0*$IemeTaxId/$NbTaxId]]
Graphe $LesX $LesY $K $Couleur "" "" "" "" "HistoDelta" $LesTags "" "BindOnly_oval" $LargeurMax $HauteurMax
} else {
# set F [AfficheListe $LaDistrib "AvecCase" $OS]
# set B [BoutonneLaFenetre $F "ShowHits" "ShowHitsFromTaxoBlast \[selection get\]"]
# $B configure -background "Magenta"
}
}
if {$GetWhat=="Show"} {
set F [AfficheListe $LaSortie "" "Delta distribution for $Clade $Seuil $SelectMethod $UseExpect"]
set B [BoutonneLaFenetre $F "Distribution" "ShowDeltaDistribution \[selection get\]"]
$B configure -background "Magenta"
}
return $LaSortie
}
proc OlymPodium {K} {
set Touche [$K find withtag current]
set LesTags [$K gettags $Touche]
lassign $LesTags Podium I J Clade Header
if {[regexp {^[0-9]+\-[0-9]+$} $Header]} {
set LesNoms [OlymStock "CaseRank-$Header" $Clade]
foreach Nom $LesNoms {
set Id [ExtraitInfo $Nom Id]
set Ac [ExtraitInfo $Nom Ac]
set ValiGN [ExtraitInfo $Nom ValiGN]
lappend LesGn $ValiGN
set ValiDE [ExtraitInfo $Nom ValiDE]
lappend LaSortie "$Nom\t$Id\t$Ac\t$ValiGN\t$ValiDE"
}
set F [AfficheListe "#n°HSAP\n$LaSortie" "AvecFetch" "Hits with rank $Header for $Clade"]
set GeneNames [join $LesGn ","]
set B [BoutonneLaFenetre $F "GeneOntology" "GoGetShowFromGeneList $GeneNames"]
$B configure -background "Magenta"
}
}
proc OlymMedals {} {
set LesClades [OlymStock ListOf Clade]
set LesTaxId [OlymStock ListOf TaxId]
set LesCasesRank [CaseRank ListOf]
set LesHeaders {}
set LesSensDuTri {}
lappend LesHeaders "Rank" "RankAv"
lappend LesSensDuTri "0red-100blue" "0red-100blue"
foreach Case $LesCasesRank {
lappend LesHeaders $Case
lappend LesSensDuTri "100red-0blue"
}
lappend LesHeaders "Score" "ScoreAv" "Expect" "ExpectAv"
lappend LesSensDuTri "100red-0blue" "100red-0blue" "0red-100blue" "0red-100blue"
foreach Clade $LesClades {
set MoyRank [OlymStock $Clade MoyenneRank]
set MoyScore [OlymStock $Clade MoyenneScore]
set MoyExpect [OlymStock $Clade MoyenneExpect]
lappend LesCladesDuRank($MoyRank) $Clade
lappend LesRanks $MoyRank
}
set LesRanks [lsort -unique -integer $LesRanks]
set LesCladesRankes {}
foreach Rank $LesRanks {
foreach Clade $LesCladesDuRank($Rank) {
lappend LesCladesRankes $Clade
}
}
set I -1
foreach Clade $LesCladesRankes {
incr I
set MoyRank [OlymStock $Clade MoyenneRank]
set MoyRankGen [OlymStock Moyenne MoyenneRank]
set MoyScore [OlymStock $Clade MoyenneScore]
set MoyScoreGen [OlymStock Moyenne MoyenneScore]
set MoyExpect [OlymStock $Clade MoyenneExpect]
set FMoyExpect [format "%4.2f" $MoyExpect]
set MoyExpectGen [OlymStock Moyenne MoyenneExpect]
set FMoyExpectGen [format "%4.2f" $MoyExpectGen]
set x -1
set T($I,[incr x]) $MoyRank
set T($I,[incr x]) $MoyRankGen
foreach Case $LesCasesRank {
set LesNoms [OlymStock "CaseRank-$Case" $Clade]
set N [llength $LesNoms]
set T($I,[incr x]) $N
}
set T($I,[incr x]) $MoyScore
set T($I,[incr x]) $MoyScoreGen
set T($I,[incr x]) $FMoyExpect
set T($I,[incr x]) $FMoyExpectGen
}
return [Medals $LesCladesRankes [array get T] $LesHeaders $LesSensDuTri]
}
proc Medals {{LesTitres ""} {LeT ""} {LesHeaders ""} {LesSensDuTri ""} {TagClick ""} {NomDe ""}} {
#rR Medals affiche un tableau rectangulaire de lignes I et de colonnes J fournies par le array LeT
#rR en début de chaque ligne il y a un titre
#rR au dessus de chaque colonne il y a un header
#rR Quand on clique sur un rectangle on exécute TagClick.
if {$TagClick==""} { set TagClick "podium" }
array set T $LeT
set LesIJ [array names T]
set LesI {}
set LesJ {}
foreach IJ $LesIJ {
lassign [split $IJ ","] I J
lappend LesI $I
lappend LesJ $J
}
set LesI [lsort -integer -unique $LesI]
set LesJ [lsort -integer -unique $LesJ]
foreach I $LesI {
foreach J $LesJ {
if { ! [info exists T($I,$J)]} { set T($I,$J) 0 }
}
}
set MaxTitreSize -1
foreach Titre $LesTitres {
set MaxTitreSize [Maxi $MaxTitreSize [string length $Titre]]
}
set K [UnCanva "" 600 1600 600 1600]
set CRed 0.1
set CBlue 0.5
set CSGx [expr $MaxTitreSize*8]
set CSGy 50
set W 50
set Ex 5
set H 20
set Ey $Ex
#set Tx 350
#set Ty 80
foreach Header $LesHeaders Sens $LesSensDuTri J $LesJ {
set HeaderDe($J) $Header
set SensDuTri($J) $Sens
set Dx [expr $CSGx + $W*$J + $Ex*$J]
set Fx [expr $Dx + $W]
set Cx [expr ($Dx+$Fx)/2]
if {[regexp {(^-?[0-9]+)\-(-?[0-9]+)$} $Header Match D S F]} { set Header $D }
$K create text $Cx [expr $CSGy-20] -text $Header -anchor center
}
foreach J $LesJ {
set Min 99999999
set Max -99999999
foreach I $LesI {
if {$T($I,$J)<$Min } {set Min $T($I,$J)}
if {$T($I,$J)>$Max } {set Max $T($I,$J)}
}
set ValeurMin($J) $Min
set ValeurMax($J) $Max
}
foreach Titre $LesTitres I $LesI {
regsub -all " " $Titre "_" Titre
set TitreDe($I) $Titre
set Dy [expr $CSGy + $H*$I + $Ex*$I]
set Fy [expr $Dy + $H]
set Cy [expr ($Dy+$Fy)/2]
$K create text 10 $Cy -text $Titre -anchor w -tags "clade $Titre"
foreach J $LesJ {
set Dx [expr $CSGx + $W*$J + $Ex*$J]
set Fx [expr $Dx + $W]
set Cx [expr ($Dx+$Fx)/2]
if {$SensDuTri($J)=="0red-100blue"} {
set Cmin $CRed
set Cmax $CBlue
} else {
set Cmin $CBlue
set Cmax $CRed
}
if {($ValeurMax($J)-$ValeurMin($J))==0} {
set Couleur [Nuance 0.5 $Cmin $Cmax]
} else {
set Couleur [Nuance [expr 1.0*($T($I,$J)-$ValeurMin($J))/($ValeurMax($J)-$ValeurMin($J))] $Cmin $Cmax]
}
$K create rectangle $Dx $Dy $Fx $Fy -fill $Couleur -tags "$TagClick $I $J $TitreDe($I) $HeaderDe($J)"
$K create text $Cx $Cy -text $T($I,$J) -anchor center -tags "$TagClick $I $J $TitreDe($I) $HeaderDe($J)"
}
}
if {$TagClick=="podium"} {
$K bind "podium" <1> "OlymPodium $K"
$K bind "clade" <1> "RunBlastOutliers $K UseExpect"
$K bind "clade" <Shift-1> "RunBlastOutliers $K UseScore"
} elseif {$TagClick=="zonard"} {
lassign [split $] Clade
$K bind "zonard" <1> "ShowZonards $K $NomDe"
$K bind "clade" <1> "RunDeltaDistributionForClade $K"
} else {
$K bind "Distri" <1> "ShowDistriHits $K"
$K bind "clade" <1> "RunBlastOutliers $K UseExpect"
$K bind "clade" <Shift-1> "RunBlastOutliers $K UseScore"
}
return $K
}
proc ShowDistriHits K {
set Touche [$K find withtag current]
set LesTags [$K gettags $Touche]
lassign $LesTags Distri I J Clade RepresentativeDelta
Espionne $LesTags
set TaxId [MemoDistri $I ItsTaxId]
set Box [MemoDistri $RepresentativeDelta ItsBox]
Espionne "$TaxId=$Box="
set LaSortie {}
foreach Delta [MemoDistri $Box ListOfDelta] {
set LesNoms [MemOlym $TaxId-$Delta ListOfNom]
Espionne "MemOlym $TaxId-$Delta ListOfNom"
Espionne $LesNoms
foreach Nom $LesNoms {
set Id [ExtraitInfo $Nom Id]
set Ac [ExtraitInfo $Nom Ac]
set ValiGN [ExtraitInfo $Nom ValiGN]
lappend LesGn $ValiGN
set ValiDE [ExtraitInfo $Nom ValiDE]
lappend LaSortie "$Nom\t$Id\t$Ac\t$ValiGN\t$ValiDE"
}
}
set F [AfficheListe "#n°HSAP\n$LaSortie" "AvecFetch" "Hits with at least $Distri for $Clade"]
set GeneNames [join $LesGn ","]
set B [BoutonneLaFenetre $F "GeneOntology" "GoGetShowFromGeneList $GeneNames"]
$B configure -background "Magenta"
}
proc RunBlastOutliers {K {UseExpect ""}} {
set Id [$K find withtag current]Seuil
set Clade [lindex [$K gettags $Id] 1]
BlastOutliers $UseExpect $Clade
}
proc NearestColor {rgb} {
set RGB [split $rgb " "]
set r [lindex $RGB 0]
set g [lindex $RGB 1]
set b [lindex $RGB 2]
set ListeRGB [Palette listof rgb ]
set Dmin [expr 255*255*3]
foreach RGB $ListeRGB {
set x [lindex $RGB 0]
set y [lindex $RGB 1]
set z [lindex $RGB 2]
set D2 [expr ($r-$x)**2 + ($g-$y)**2 + ($b-$z)**2 ]
if {$D2<$Dmin} { set Dmin $D2; set NearestRGB $RGB}
}
return $NearestRGB
}
proc TousLesPremiersDuClade {Nom LesOrganismesInteressants {Seuil ""} {GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "Show" }
if {$Seuil==""} { set Seuil 0.001 }
set LesOrgaTrie [LesLignesDuFichier [GscopeFile $Nom "taxobla"]]
if {$LesOrgaTrie=={}} { return "The file taxobla/$Nom does not exist" }
set LaSortie {}
foreach Ligne $LesOrgaTrie {
lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
set TaxId [string trim $TaxId]
set OS [string trim $OS]
set Reste [string trim $Reste]
if {[lsearch $LesOrganismesInteressants $TaxId]<0} { continue }
set Expect [string trim $Expect]
if {$Expect > $Seuil} { break }
lappend LaSortie $Ligne
}
if {$LaSortie=={}} { return "" }
if {[regexp "/" $GetWhat] || [string equal -nocase "Save" $GetWhat]} {
set FichierPremiers $GetWhat
if {[string equal -nocase "Save" $GetWhat]} { set FichierPremiers [GscopeFile $Nom premier] }
return [SauveLesLignes $LaSortie dans $FichierPremiers]
}
if {[string equal -nocase "GetList" $GetWhat]} { return $LaSortie }
if {[string equal -nocase "GetText" $GetWhat]} { return [join $LaSortie "\n"] }
return [AfficheListe $LaSortie]
}
proc HistoPremier {{Clade ""} {Seuil ""} {GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "Show" }
if {$Seuil==""} { set Seuil 0.001 }
if {$Clade==""} { set Clade [ReferenceClade] }
if {[OnTraite CiloCarta Like]} {
set LesTaxIdsInteressants [QuestionDeScience CilioCarta "ret CladeContent $Clade"]
} elseif {[OnTraite OI2017 Like]} {
set LesTaxIdsInteressants [QuestionDeScience OI "ret CladeContentWithinOi2017 $Clade"]
} else {
FaireLire "Désolé il faut être LioCarta Like ou OI2017 Like"
}
set LesMeilleurs {}
set N 0
foreach Nom [ListeDesPABs] {
if {$N%100==0} { Espionne "$N $Nom" }
if {$Nom>"HSAP01000"} { break }
set LesPremiers [TousLesPremiersDuClade $Nom $LesTaxIdsInteressants "" "GetList"]
if {$LesPremiers=={}} { continue }
incr N
set P [lindex $LesPremiers 0]
lassign $P PN TaxId OS
if { ! [info exists Cumul($TaxId)]} {
set Cumul($TaxId) 0
lappend LesMeilleurs $TaxId
}
incr Cumul($TaxId)
}
set LesMeilleurs [lsort -unique $LesMeilleurs]
foreach Meilleur $LesMeilleurs {
set C $Cumul($Meilleur)
lappend LesCumularsDe($C) $Meilleur
}
set LesC [array names LesCumularsDe]
set LesMeilleursTries {}
foreach C [lsort -decreasing -integer $LesC] {
LConcat LesMeilleursTries $LesCumularsDe($C)
}
foreach Meilleur $LesMeilleursTries {
lappend LaSortie "$Cumul($Meilleur) $Meilleur [Tax $Meilleur Name]"
}
return $LaSortie
EspionneL $LaSortie
SauveLesLignes [array get LesCumularsDe] dans "/home/scherb/gscoperso/Cumulars.txt"
set LesC {}
foreach C [lsort -integer [array names LesCumularsDe]] {
lappend LesC $C
lappend LesNC [llength $LesCumularsDe($C)]
}
Espionne $LesC
Espionne $LesNC
return [Graphe $LesC $LesNC "" "" "" "" "" "" "Histogramme coucou"]
}
proc HistoPremierMemo {{FichierCumulars ""}} {
if {$FichierCumulars=={}} { set FichierCumulars "/home/scherb/gscoperso/Cumulars.txt" }
array set LesCumularsDe [LesLignesDuFichier $FichierCumulars]
parray LesCumularsDe
set LesC {}
foreach C [lsort -integer [array names LesCumularsDe]] {
lappend LesC $C
lappend LesNC [llength $LesCumularsDe($C)]
}
Espionne $LesC
Espionne $LesNC
return [Graphe $LesC $LesNC "" "" "" "" "" "" "Histogramme coucou"]
}
proc TailleProteome Qui {
global TailleProteome
if {[OnTraite "OI2017" "Like"]} {
return [OiProteomeSize $Qui]
}
if {[info exists TailleProteome($Qui)]} { return $TailleProteome($Qui) }
if {[info exists TailleProteome("EstCharge")]} { return -1 }
set TailleProteome("EstCharge") 1
set Fichier "[RepertoireDuGenome]/banques/Proteome201501_TaillesDesOs.txt"
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp {^([0-9]+)[ \t].+_([0-9]+)} $Ligne Match Taille TaxId]} { continue }
set TailleProteome($TaxId) $Taille
}
set TailleProteome(9606) 20193 ; #rR dans la banque il y en a 66922
#rR on n'a gardé que les swissprot
return [TailleProteome $Qui]
}
proc TestMemoDelta {} {
MemoDelta a b x
MemoDelta a b y
MemoDelta a b z
Espionne [MemoDelta a b]
Espionne [MemoDelta a r]
MemoDelta Reset
MemoDelta a b y
MemoDelta a b z
Espionne [MemoDelta a b]
Espionne [MemoDelta a r]
}
proc MemoDelta {{Qui ""} {Quoi ""} {Valeur ""}} {
global MemoDelta
set Qui [string trim $Qui]
set Quoi [string trim $Quoi]
if {$Qui=="Reset"} {
if {[info exists MemoDelta]} { unset MemoDelta }
return ""
}
if {$Valeur==""} {
if {[info exists MemoDelta($Qui,$Quoi)]} { return $MemoDelta($Qui,$Quoi) }
if {[info exists MemoDelta("EstCHarge")]} { return "" }
}
set MemoDelta("EstCHarge") 1
lappend MemoDelta($Qui,$Quoi) $Valeur
return [MemoDelta $Qui $Quoi]
}
proc MemoInfo {{Qui ""} {Quoi ""} {Valeur ""}} {
global MemoInfo
set Qui [string trim $Qui]
set Quoi [string trim $Quoi]
if {$Qui=="Reset"} {
if {[info exists MemoInfo]} { unset MemoInfo }
return ""
}
if {$Valeur==""} {
if {[info exists MemoInfo($Qui,$Quoi)]} { return $MemoInfo($Qui,$Quoi) }
if {[info exists MemoInfo("EstCHarge")]} { return "" }
}
set MemoInfo("EstCHarge") 1
lappend MemoInfo($Qui,$Quoi) $Valeur
return [MemoInfo $Qui $Quoi]
}
proc MemoCase {{Qui ""} {Quoi ""} {Valeur ""}} {
global MemoCase
set Qui [string trim $Qui]
set Quoi [string trim $Quoi]
if {$Qui=="Reset"} {
if {[info exists MemoCase]} { unset MemoCase }
return ""
}
if {$Valeur==""} {
if {[info exists MemoCase($Qui,$Quoi)]} { return $MemoCase($Qui,$Quoi) }
if {[info exists MemoCase("EstCHarge")]} { return "" }
}
set MemoCase("EstCHarge") 1
set MemoCase($Qui,$Quoi) $Valeur
return [MemoCase $Qui $Quoi]
}
proc MemoDistri {{Qui ""} {Quoi ""} {Valeur ""}} {
global MemoDistri
set Qui [string trim $Qui]
set Quoi [string trim $Quoi]
if {$Qui=="Reset"} {
if {[info exists MemoDistri]} { unset MemoDistri }
return ""
}
if {$Valeur==""} {
if {[info exists MemoDistri($Qui,$Quoi)]} { return $MemoDistri($Qui,$Quoi) }
if {[info exists MemoDistri("EstCHarge")]} { return "" }
}
set MemoDistri("EstCHarge") 1
lappend MemoDistri($Qui,$Quoi) $Valeur
return [MemoDistri $Qui $Quoi]
}
proc BlastOutliers {{UseExpect ""} {Clade ""}} {
return [HistoDelta $Clade "" Show "" $UseExpect]
}
proc ShowDeltaDistributionForClade {{Clade ""} {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {
set LesLignes [HistoDelta $Clade $Seuil "GetList" $SelectMethod $UseExpect]
set T(Min,Delta) 99999
set T(Max,Delta) -99999
foreach Ligne $LesLignes {
if {[regexp "^#" $Ligne]} { continue }
regsub -all {[ \t]+} $Ligne " " Ligne
set LesMots [split [string trim $Ligne] " "]
lassign $LesMots TailleProteome NbDelta Moyenne TaxId
set OS [join [lrange $LesMots 4 end] " "]
set T($TaxId,OS) $OS
set LaDistrib [MemoCase $TaxId "LaDistrib"]
lappend T(ListOf,TaxId) $TaxId
set T($TaxId,MinDelta) 99999
set T($TaxId,MaxDelta) -99999
foreach Distri $LaDistrib {
if {[regexp "^#" $Distri]} { continue }
lassign [split $Distri "\t"] Delta Count Case tid o RefCla
regsub -all " " $Delta "" Delta
regsub -all " " $Count "" Count
regsub -all " " $Case "" Case
regsub "ReferenceClade:" $RefCla "" ReferenceClade
Espionne "$Delta $Count $Case"
set T($TaxId,$Delta) $Count
set T($TaxId,MinDelta) [Mini $T($TaxId,MinDelta) $Delta]
set T($TaxId,MaxDelta) [Maxi $T($TaxId,MaxDelta) $Delta]
lappend T($Delta,ListOfTaxId) $TaxId
lappend T(ListOf,Delta) $Delta
}
set T(Min,Delta) [Mini $T(Min,Delta) $T($TaxId,MinDelta)]
set T(Max,Delta) [Maxi $T(Max,Delta) $T($TaxId,MaxDelta)]
}
set UseExpect [string equal -nocase $UseExpect "UseExpect"]
if {$UseExpect} {
set T(ListOf,Delta) [lsort -integer -decreasing $T(ListOf,Delta)]
} else {
set T(ListOf,Delta) [lsort -integer -increasing $T(ListOf,Delta)]
}
set LesHeaders {}
set Box 0
set LesDelta $T(ListOf,Delta)
set OnBreak 0
while {1} {
set N [llength $LesDelta]
Espionne $LesDelta
set Portion [expr $N/3]
if {$N<12} {
set LesCourants $LesDelta
set OnBreak 1
} else {
set PortionMoinsUn [expr $Portion-1]
set LesCourants [lrange $LesDelta end-$Portion end]
set LesDelta [lrange $LesDelta 0 end-$PortionMoinsUn]
}
Espionne "Box $Box : $LesCourants"
set BoxVide($Box) 1
foreach D $LesCourants {
if {[info exists DejaVu($D)]} { continue }
set DejaVu($D) 1
foreach TaxId $T($D,ListOfTaxId) {
set BoxVide($Box) 0
set BM1 [expr $Box - 1]
if { ! [info exists CumulParBox($BM1,$TaxId)]} { set CumulParBox($BM1,$TaxId) 0 }
if { ! [info exists CumulParBox($Box,$TaxId)]} { set CumulParBox($Box,$TaxId) $CumulParBox($BM1,$TaxId) }
incr CumulParBox($Box,$TaxId) $T($TaxId,$D)
Espionne "incr CumulParBox($Box,$TaxId) $T($TaxId,$D) > $CumulParBox($Box,$TaxId)"
}
MemoDistri $Box ListOfDelta $D
}
if { ! $BoxVide($Box) } {
set Delta [lindex $LesCourants 0]
MemoDistri $Delta ItsBox $Box
lappend LesHeaders $Delta
}
if {$OnBreak} { break }
incr Box
}
set MaxBox $Box
set I 0
foreach TaxId $T(ListOf,TaxId) {
set Box 0
set LaLigne {}
foreach Box [NombresEntre 0 $MaxBox] {
if {$BoxVide($Box)} { continue }
if { ! [info exists CumulParBox($Box,$TaxId)]} { set CumulParBox($Box,$TaxId) 0 }
lappend LaLigne [format "%7d" $CumulParBox($Box,$TaxId)]
set W($I,$Box) $CumulParBox($Box,$TaxId)
incr Box
}
Espionne "[format %-30s $T($TaxId,OS)] [join $LaLigne { }]"
lappend LesTitres $T($TaxId,OS)
MemoDistri $I ItsTaxId $TaxId
incr I
}
set NbBox [expr $MaxBox + 1]
if {$UseExpect} {
set LesSensDuTri [string repeat "100red-0blue" $NbBox]
} else {
set LesSensDuTri [string repeat "0blue-100red" $NbBox]
}
set LeW [array get W]
return [Medals $LesTitres $LeW $LesHeaders $LesSensDuTri "Distri"]
}
proc ShowDeltaDistribution {Selection} {
set LesFenetres {}
foreach Sel [split $Selection "\n"] {
if {[regexp "^#" $Sel]} { continue }
regsub -all {[ \t]+} $Sel " " Sel
set Sel [string trim $Sel]
set TaxId [lindex [split $Sel " "] 3]
set LaDistrib [MemoCase $TaxId "LaDistrib"]
if {$LaDistrib==""} { continue }
regsub -all {[ \t]+} $Sel " " SelPourTitre
set F [AfficheListe $LaDistrib "AvecCase" "Delta distribution concerning $SelPourTitre"]
set B [BoutonneLaFenetre $F "ShowHits" "ShowHitsFromTaxoBlast \[selection get\]"]
$B configure -background "Magenta"
lappend LesFenetres $F
}
return $LesFenetres
}
proc ShowHitsFromTaxoBlast {Selection} {
set LaSortie [list "#[PreFixe] EcartMoy Moyenne Id VaLign Valide NumeroDuTaxId OS Reference"]
set LesGn {}
foreach Sel [split $Selection "\n"] {
if {[regexp "^#" $Sel]} { continue }
regsub -all {[ \t]+} $Sel " " Sel
lassign [split [string trim $Sel] " "] Delta N Case
set TaxId [StringApres "TaxId:" dans $Sel]
set OS [StringApres "OS:" dans $Sel]
set Clade [StringApres "ReferenceClade:" dans $Sel]
set LesAccess {}
foreach Info [MemoInfo $TaxId $Case] {
scan $Info "%s" Nom
set Id [ExtraitInfo $Nom Id]
set Ac [ExtraitInfo $Nom Ac]
set ValiGN [ExtraitInfo $Nom ValiGN]
lappend LesGn $ValiGN
set ValiDE [ExtraitInfo $Nom ValiDE]
lappend LaSortie $Info\t$Id\t$Ac\t$ValiGN\t$ValiDE\tTaxId:$TaxId\tOS:$OS\tReferenceClade:$Clade
}
}
set LaSortie [lsort -unique $LaSortie]
set GeneNames [join $LesGn ","]
set F [AfficheListe $LaSortie "" "$TaxId [TaxClass $TaxId Name Reverse]"]
set B [BoutonneLaFenetre $F "GeneOntology" "GoGetShowFromGeneList $GeneNames"]
$B configure -background "Magenta"
set B [BoutonneLaFenetre $F "Outliers" "OutliersFromSelection \[selection get\]"]
$B configure -background "Magenta"
return $F
}
proc OutliersFromSelection Selection {
foreach Sel [split $Selection "\n"] {
if {[regexp "^#" $Sel]} { continue }
scan $Sel "%s" Nom
set TaxId [StringApres "TaxId:" dans $Sel]
set OS [StringApres "OS:" dans $Sel]
set Clade [StringApres "ReferenceClade:" dans $Sel]
set Seuil ""
lappend LesFenetres [OutlierOrganismInBlast $Nom $TaxId $Clade $Seuil "Show"]
}
return $LesFenetres
}
proc GoGetShowFromGeneListWithNom LesNoms {
set Noms [join $LesGn ","]
set LesGnGO [GoGetFromGeneList $GeneNames "GOacc,name" "" "\t"]
foreach GnGO $LesGnGO {
if {[regexp {^([^=]+)=(.*)$} $GnGO Match Gn GOsPropres]} {
set GOs $GOsPropres
lappend LesGenesEtLeursGOs "\n$Gn *************"
}
foreach GO [split $GOs "\t"] {
lassign $GO GoAcc GoName
lappend LesGoAcc $GoAcc
lappend LesGoName $GoName
set GoAccName "$GoAcc $GoName"
lappend LesGenesEtLeursGOs "$Gn $GoAccName"
lappend LesGenesDu($GoAccName) $Gn
set LesGenesDu($GoAccName) [lsort -unique $LesGenesDu($GoAccName)]
}
}
set LesNombres {}
set LesGOsEtLeursGenes [list "#GeneCount GO Genes"]
foreach {GoAccName Genes} [array get LesGenesDu] {
set Nombre [llength $Genes]
lappend LesNombres $Nombre
lappend LesGoDeLaLongueur($Nombre) $GoAccName
}
set LesNombres [lsort -integer -unique -decreasing $LesNombres]
foreach Nombre $LesNombres {
foreach GoAccName $LesGoDeLaLongueur($Nombre) {
lappend LesGOsEtLeursGenes " $Nombre $GoAccName"
set Genes [join $LesGenesDu($GoAccName) " "]
set TexteAAfficher $Genes
while {[string length $TexteAAfficher]>80} {
set Debut [string range $TexteAAfficher 0 79]
set iDBlanc [string last " " $Debut]
set BonDebut [string range $TexteAAfficher 0 $iDBlanc-1]
set TexteAAfficher [string range $TexteAAfficher $iDBlanc+1 end]
lappend LesGOsEtLeursGenes "[string repeat { } 40] $BonDebut"
}
if {$TexteAAfficher != ""} {
lappend LesGOsEtLeursGenes "[string repeat { } 40] $TexteAAfficher"
}
}
}
set LesFenetres {}
#set F [AfficheListe $LesGenesEtLeursGOs "GrandeLargeur" "Genes With their GOs"]
lappend LesFenetres [AfficheListe $LesGOsEtLeursGenes "GrandeLargeur" "GOs with their genes"]
return $LesFenetres
}
proc GoGetShowFromGeneList LesGn {
set GeneNames [join $LesGn ","]
set LesGnGO [GoGetFromGeneList $GeneNames "GOacc,name" "" "\t"]
foreach GnGO $LesGnGO {
if {[regexp {^([^=]+)=(.*)$} $GnGO Match Gn GOsPropres]} {
set GOs $GOsPropres
lappend LesGenesEtLeursGOs "\n$Gn *************"
}
foreach GO [split $GOs "\t"] {
lassign $GO GoAcc GoName
lappend LesGoAcc $GoAcc
lappend LesGoName $GoName
set GoAccName "$GoAcc $GoName"
lappend LesGenesEtLeursGOs "$Gn $GoAccName"
lappend LesGenesDu($GoAccName) $Gn
set LesGenesDu($GoAccName) [lsort -unique $LesGenesDu($GoAccName)]
}
}
set LesNombres {}
set LesGOsEtLeursGenes [list "#GeneCount GO Genes"]
foreach {GoAccName Genes} [array get LesGenesDu] {
set Nombre [llength $Genes]
lappend LesNombres $Nombre
lappend LesGoDeLaLongueur($Nombre) $GoAccName
}
set LesNombres [lsort -integer -unique -decreasing $LesNombres]
foreach Nombre $LesNombres {
foreach GoAccName $LesGoDeLaLongueur($Nombre) {
lappend LesGOsEtLeursGenes " $Nombre $GoAccName"
set Genes [join $LesGenesDu($GoAccName) " "]
set TexteAAfficher $Genes
while {[string length $TexteAAfficher]>80} {
set Debut [string range $TexteAAfficher 0 79]
set iDBlanc [string last " " $Debut]
set BonDebut [string range $TexteAAfficher 0 $iDBlanc-1]
set TexteAAfficher [string range $TexteAAfficher $iDBlanc+1 end]
lappend LesGOsEtLeursGenes "[string repeat { } 40] $BonDebut"
}
if {$TexteAAfficher != ""} {
lappend LesGOsEtLeursGenes "[string repeat { } 40] $TexteAAfficher"
}
}
}
set LesFenetres {}
#set F [AfficheListe $LesGenesEtLeursGOs "GrandeLargeur" "Genes With their GOs"]
lappend LesFenetres [AfficheListe $LesGOsEtLeursGenes "GrandeLargeur" "GOs with their genes"]
return $LesFenetres
}
proc LesNomsPourOlymClade {} {
set LesNoms [ListeDesPABs]
# set LesNoms [lrange $LesNoms 0 999]
return $LesNoms
}
proc ChallengingClades {{Qui ""} {Quoi ""}} {
#rR Connait les TaxIds des clades et le clade des TaxIds
global ChallengingClades
set LesClades {}
if {$Qui=="Load"} {
if {[info exists ChallengingClades]} { unset ChallengingClades }
set LesClades $Quoi
set Qui "ListOf"
set Quoi "Clade"
}
if {[info exists ChallengingClades($Qui,$Quoi)]} { return $ChallengingClades($Qui,$Quoi) }
if {[info exists ChallengingClades("EstCharge")]} { return "" }
set ChallengingClades("EstCharge") 1
if {$LesClades=={}} { set LesClades [SelectClade "Multiple"] }
set ChallengingClades(ListOf,Clade) {}
set ChallengingClades(ListOf,TaxId) {}
foreach Clade $LesClades {
Espionne $Clade
lappend ChallengingClades(ListOf,Clade) $Clade
if {[OnTraite "CilioCarta" "Like"]} {
set LesTaxIdsDuClade [QuestionDeScience CilioCarta "ret CladeContent $Clade"]
} elseif {[OnTraite "OI2017" "Like"]} {
# set LesTaxIdsDuClade [QuestionDeScience OI "ret CladeContentWithinOi2017 $Clade"]
set LesTaxIdsDuClade [CladeContentWithinOi2017 $Clade]
Espionne "CladeContentWithinOi2017 $Clade"
Espionne "LesTaxIdsDuClade $Clade = $LesTaxIdsDuClade"
}
if {[set i [lsearch $LesTaxIdsDuClade [NotreOX]]]>=0} {
set LesTaxIdsDuClade [lreplace $LesTaxIdsDuClade $i $i]
}
set ChallengingClades($Clade,Content) $LesTaxIdsDuClade
LConcat ChallengingClades(ListOf,TaxId) $LesTaxIdsDuClade
foreach TaxId $LesTaxIdsDuClade {
set ChallengingClades($TaxId,Clade) $Clade
}
Espionne $LesTaxIdsDuClade
}
return [ChallengingClades $Qui $Quoi]
}
proc OlymStock {{Qui ""} {Quoi ""} {Valeur ""}} {
global OlymStock
if {$Valeur==""} {
if {[info exists OlymStock($Qui,$Quoi)]} { return $OlymStock($Qui,$Quoi) }
if { ! [info exists OlymStock]} {
OlymClade ; #rR c'est là qu'on range tout !
return [OlymStock $Qui $Quoi]
}
if {[info exists OlymStock(EstCharge)]} { return "" }
}
if {$Qui=="CalculateAll"} {
set OlymStock($Qui,EstCharge) 1
set OlymStock(ListOf,Clade) [lsort -unique $OlymStock(ListOf,Clade)]
foreach Clade $OlymStock(ListOf,Clade) {
set SommeExpect 0
set SommeScore 0
set SommeRank 0
set NbNom 0
foreach Nom [LesNomsPourOlymClade] {
if { ! [info exists OlymStock($Nom,$Clade-MoyenneExpect)]} { continue }
incr NbNom
set SommeExpect [expr $SommeExpect + $OlymStock($Nom,$Clade-MoyenneExpect)]
set SommeScore [expr $SommeScore + $OlymStock($Nom,$Clade-MoyenneScore)]
set SommeRank [expr $SommeRank + $OlymStock($Nom,$Clade-MoyenneRank)]
}
if {$NbNom==0} { continue }
set MoyenneExpect [expr $SommeExpect/$NbNom]
set MoyenneScore [expr $SommeScore/$NbNom]
set MoyenneRank [expr $SommeRank/$NbNom]
set OlymStock($Clade,NbNom) $NbNom
set OlymStock($Clade,MoyenneExpect) $MoyenneExpect
set OlymStock($Clade,MoyenneScore) $MoyenneScore
set OlymStock($Clade,MoyenneRank) $MoyenneRank
}
set SommeMoyenneExpect 0
set SommeMoyenneScore 0
set SommeMoyenneRank 0
set NbClade 0
foreach Clade $OlymStock(ListOf,Clade) {
if { ! [info exists OlymStock($Clade,MoyenneExpect)]} { continue }
incr NbClade
set SommeMoyenneExpect [expr $SommeMoyenneExpect + $OlymStock($Clade,MoyenneExpect)]
set SommeMoyenneScore [expr $SommeMoyenneScore + $OlymStock($Clade,MoyenneScore)]
set SommeMoyenneRank [expr $SommeMoyenneRank + $OlymStock($Clade,MoyenneRank)]
}
if {$NbClade==0} { parray OlymStock }
set MoyenneMoyenneExpect [expr $SommeMoyenneExpect/$NbClade]
set MoyenneMoyenneScore [expr $SommeMoyenneScore/$NbClade]
set MoyenneMoyenneRank [expr $SommeMoyenneRank/$NbClade]
OlymStock Moyenne MoyenneExpect $MoyenneMoyenneExpect
OlymStock Moyenne MoyenneScore $MoyenneMoyenneScore
OlymStock Moyenne MoyenneRank $MoyenneMoyenneRank
#rR on en fait quoi ???
set OlymStock(EstCharge) 1
}
lappend OlymStock($Qui,$Quoi) $Valeur ; #rR attention on fait toujours lappend
return $OlymStock($Qui,$Quoi)
}
proc CaseRank Valeur {
global CaseRank
if { ! [info exists CaseRank]} {
# set CaseRank(Deb) [list 0 20 40 60 80 100]
set Pas 1
set Pos 0
while {1} {
if {$Pos>17} { break }
lappend CaseRank(Deb) $Pos
incr Pos $Pas
}
set CaseRank(Deb)
set CaseRank(Fin) [lrange $CaseRank(Deb) 1 end]
lappend CaseRank(Fin) 100
foreach D $CaseRank(Deb) F $CaseRank(Fin) {
lappend CaseRank(ListOf) "$D-$F"
}
}
if {[info exists CaseRank($Valeur)]} { return $CaseRank($Valeur) }
foreach D $CaseRank(Deb) F $CaseRank(Fin) {
if {$D <= $Valeur && $Valeur <= $F} { return "$D-$F" }
}
return ""
}
proc OlymClade {{Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""} {Clades ""}} {
#rR On veut faire un classemnent des clades en fonction du comportement des 20000 blast par rapport au projet courant (initalement Homo sapiens)
#rR OlymClade ne fait que remplir le tableau OlymStock puis lance les calculs par OlymStock CalculateAll
if {$Clades!=""} { ChallengingClades "Load" $Clades }
if {$UseExpect==""} { set UseExpect "UseExpect" }
if {$SelectMethod==""} { set SelectMethod "FirstOnly" }
if {$GetWhat==""} { set GetWhat "Show" }
if {$Seuil==""} { set Seuil 99999 }
set iNom 0
foreach Nom [LesNomsPourOlymClade] {
set FiTaxobla [GscopeFile $Nom taxobla]
if {[FileAbsent $FiTaxobla]} { continue }
set LesCladesDuNom {}
if {[info exists SommeExpect]} { unset SommeExpect }
if {[info exists SommeScore]} { unset SommeScore }
set LesLignes [LesLignesDuFichier $FiTaxobla]
set NbHitDuNom [llength $LesLignes]
if {$NbHitDuNom==0} { continue }
OlymStock $Nom NbHits $NbHitDuNom
set iLigne 0
if {[info exists DejaVuCeClade]} { unset DejaVuCeClade }
foreach Ligne $LesLignes {
incr iLigne
set Rank [expr round(100*$iLigne/$NbHitDuNom)]
lassign [split $Ligne "\t"] Expect Score TaxId OS Reste
if {$Expect==0.0} { set Expect 1.0e-250 }
# if {$Expect >1.0} { set Expect 1.0 }
set TaxId [string trim $TaxId]
set OS [string trim $OS]
set Reste [string trim $Reste]
if {[set Clade [ChallengingClades $TaxId Clade]]==""} { continue } ;#rR on ne s'interesse qu'aux TaxIds qui sont dans un Clade participant
if {[info exists DejaVuCeClade($Clade)]} { continue }
set DejaVuCeClade($Clade) 1
lappend LesCladesDuNom $Clade
set Rank [llength [array names DejaVuCeClade]] ;#rR attention on triche a fond !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
OlymStock ListOf Clade $Clade
OlymStock ListOf TaxId $TaxId
OlymStock $Clade Content $TaxId
set Expect [string trim $Expect]
set Score [string trim $Score]
set Score [expr round($Score)]
if {$Expect > $Seuil} { break }
set Expect [expr log10($Expect)] ; #rR attention on prend le log !!!!!!!!
lappend LesExpects $Expect
lappend LesScores $Score
lappend LesRanks $Rank
OlymStock $TaxId Expect$Nom $Expect
OlymStock $TaxId Score$Nom $Score
OlymStock $TaxId Rank$Nom $Rank
lappend LesChoisis "$Expect\t$Score\t$TaxId\t$OS\t$Reste"
if { ! [info exists SommeExpect($Clade)]} { set SommeExpect($Clade) 0 }
if { ! [info exists SommeScore($Clade)]} { set SommeScore($Clade) 0 }
if { ! [info exists SommeRank($Clade)]} { set SommeRank($Clade) 0 }
set SommeExpect($Clade) [expr $SommeExpect($Clade) + $Expect]
set SommeScore($Clade) [expr $SommeScore($Clade) + $Score]
set SommeRank($Clade) [expr $SommeRank($Clade) + $Rank]
if { ! [info exists NbHitDuClade($Clade)]} { set NbHitDuClade($Clade) 0 }
incr NbHitDuClade($Clade)
}
set LesCladesDuNom [ListeSansDoublon $LesCladesDuNom]
set SommeMoyennesExpect 0
set SommeMoyennesScore 0
set SommeMoyennesRank 0
foreach Clade $LesCladesDuNom {
set MoyenneExpect($Clade) [expr $SommeExpect($Clade)/$NbHitDuClade($Clade)]
set MoyenneScore($Clade) [expr $SommeScore($Clade)/$NbHitDuClade($Clade)]
set MoyenneRank($Clade) [expr $SommeRank($Clade)/$NbHitDuClade($Clade)]
OlymStock $Nom $Clade-MoyenneExpect $MoyenneExpect($Clade)
OlymStock $Nom $Clade-MoyenneScore $MoyenneScore($Clade)
OlymStock $Nom $Clade-MoyenneRank $MoyenneRank($Clade)
set SommeMoyennesExpect [expr $SommeMoyennesExpect + $MoyenneExpect($Clade)]
set SommeMoyennesScore [expr $SommeMoyennesScore + $MoyenneScore($Clade)]
set SommeMoyennesRank [expr $SommeMoyennesRank + $MoyenneRank($Clade)]
set Case [CaseRank $MoyenneRank($Clade)]
OlymStock ListOf CaseRank $Case
OlymStock "CaseRank-$Case" $Clade $Nom
}
set NbCladesDuNom [llength $LesCladesDuNom]
if {$NbCladesDuNom==0} { continue }
OlymStock $Nom ListOfClade $LesCladesDuNom
set MoyennesExpect [expr $SommeMoyennesExpect/$NbCladesDuNom]
set MoyennesScore [expr $SommeMoyennesScore/$NbCladesDuNom]
set MoyennesRank [expr $SommeMoyennesRank/$NbCladesDuNom]
OlymStock $Nom MoyennesExpect $MoyennesExpect
OlymStock $Nom MoyennesScore $MoyennesScore
OlymStock $Nom MoyennesRank $MoyennesRank
foreach Clade $LesCladesDuNom {
OlymStock $Nom $Clade-DeltaExpect [expr $MoyenneExpect($Clade)- $MoyennesExpect]
OlymStock $Nom $Clade-DeltaScore [expr $MoyenneScore($Clade) - $MoyennesScore]
OlymStock $Nom $Clade-DeltaRank [expr $MoyenneRank($Clade) - $MoyennesRank]
#rR c'est ici qu'il faut les ranger dans des cases (on va peut-etre commencer par seulement les rank ...)
}
}
OlymStock CalculateAll
}
proc TestMoyenneRank {} {
set LesClades [OlymStock ListOf Clade]
# set LesClades [list Deuterostomia Fungi]
foreach Nom [ListeDesPABs] {
foreach Clade $LesClades {
set M [OlymStock $Nom $Clade-MoyenneRank]
Espionne "$Nom $M $Clade"
}
}
}
proc CladeChallenge {{Challenger ""} {Referencer ""} {Seuil ""} {GetWhat ""} {SelectMethod ""} {UseExpect ""}} {
FaireLire "Pas encore fini ... on voudrait comparer deux clades .. le meilleur de l'un par rapport à l'autre ???"
if {$Challenger==""} { set Challenger [SelectOneClade] }
if {$Referencer==""} { set Referencer [SelectOneClade] }
set EnTest [regexp {^(ripp|scherb)$} [Login]]
# set EnTest 0
if {$UseExpect==""} { set UseExpect "UseScore" }
if {$GetWhat==""} { set GetWhat "Show" }
if {$Seuil==""} { set Seuil 99999 }
regsub -all " " $Challenger "_" ChallengerUnderscore
regsub -all " " $Referencer "_" ReferencerUnderscore
set UseExpect [string equal -nocase "UseExpect" $UseExpect]
set Echantillonage 20
if {[OnTraite CilioCarta Like]} {
set LesTaxIdsChallenger [QuestionDeScience CilioCarta "ret CladeContent $Challenger"]
set LesTaxIdsReferencer [QuestionDeScience CilioCarta "ret CladeContent $Referencer"]
} elseif {[OnTraite OI2017 Like]} {
set LesTaxIdsChallenger [QuestionDeScience OI "ret CladeContentWithinOi2017 $Challenger"]
set LesTaxIdsReferencer [QuestionDeScience OI "ret CladeContentWithinOI2017 $Referencer"]
} else {
}
set NbTaxIdChallenger [llength $LesTaxIdsChallenger]
set NbTaxIdReferencer [llength $LesTaxIdsReferencer]
# on fait l'initialisation
foreach TaxId $LesTaxIdsReferencer {
set SommeDesDeltasReferencerPour($TaxId) 0.0
set NbDeltasReferencerPour($TaxId) 0
}
set LesMeilleursChallenger {}
set LesMeilleursReferencer {}
set NbNomChallenger 0
set NbNomReferencer 0
foreach Nom [ListeDesPABs] {
if {0 && $NbNom%100==0} { Espionne "$NbNom $Nom" }
if {$EnTest && $Nom>"HSAP20193"} { break }
set LesHitsAvecDeltaChallenger [LesHitsAvecDelta $Nom $LesTaxIdsChallenger $Seuil "GetList" $SelectMethod $UseExpect]
set LesHitsAvecDeltaReferencer [LesHitsAvecDelta $Nom $LesTaxIdsReferencer $Seuil "GetList" $SelectMethod $UseExpect]
if {$LesHitsAvecDeltaChallenger!={}} {
incr NbNomChallenger
foreach HitAvecDelta $LesHitsAvecDeltaChallenger {
lassign $HitAvecDelta Delta Expect Score TaxId OS Reste
regsub -all "\t" $OS " " OS
set SommeDesDeltasChallengerPour($TaxId) [expr $SommeDesDeltasChallengerPour($TaxId)+$Delta]
set InfoDu($TaxId) "$OS\t$Reste"
incr NbDeltasChallengerPour($TaxId)
lappend LesDeltasChallengerDe($TaxId) $Delta
lappend LesNomsChallengerDe($TaxId,$Delta) $Nom
MemoDelta $TaxId $Delta $Nom
}
}
if {$LesHitsAvecDeltaReferencer!={}} {
incr NbNomReferencer
foreach HitAvecDelta $LesHitsAvecDeltaReferencer {
lassign $HitAvecDelta Delta Expect Score TaxId OS Reste
regsub -all "\t" $OS " " OS
set SommeDesDeltasReferencerPour($TaxId) [expr $SommeDesDeltasReferencerPour($TaxId)+$Delta]
set InfoDu($TaxId) "$OS\t$Reste"
incr NbDeltasReferencerPour($TaxId)
lappend LesDeltasReferencerDe($TaxId) $Delta
lappend LesNomsReferencerDe($TaxId,$Delta) $Nom
MemoDelta $TaxId $Delta $Nom
}
}
}
foreach TaxId $LesTaxIdsChallenger {
set Moyenne [expr $SommeDesDeltasChallengerPour($TaxId)/$NbDeltasChallengerPour($TaxId)]
set MoyenneDesDeltasChallengerPour($TaxId) $Moyenne
lappend LesMoyennesDesDeltasChallenger $Moyenne
lappend LesTaxIdsDeLaMoyenneDesDeltasChallenger($Moyenne) $TaxId
}
foreach TaxId $LesTaxIdsReferencer {
set Moyenne [expr $SommeDesDeltasReferencerPour($TaxId)/$NbDeltasReferencerPour($TaxId)]
set MoyenneDesDeltasReferencerPour($TaxId) $Moyenne
lappend LesMoyennesDesDeltasReferencer $Moyenne
lappend LesTaxIdsDeLaMoyenneDesDeltasReferencer($Moyenne) $TaxId
}
if {$UseExpect} {
set LesMoyennesDesDeltasChallenger [lsort -unique -real $LesMoyennesDesDeltasChallenger]
set LesMoyennesDesDeltasReferencer [lsort -unique -real $LesMoyennesDesDeltasChallenger]
} else {
set LesMoyennesDesDeltasChallenger [lsort -decreasing -unique -real $LesMoyennesDesDeltasChallenger]
set LesMoyennesDesDeltasReferencer [lsort -decreasing -unique -real $LesMoyennesDesDeltasReferencer]
}
#####################################################################################################################
set LaSortie [list "# TailleP NombreDeDelta Moyenne TaxId Nom_de_l'espece "]
foreach Moyenne $LesMoyennesDesDeltasChallenger {
foreach TaxId $LesTaxIdsDeLaMoyenneDesDeltasChallenger($Moyenne) {
set BelleMoyenne [format "%6.0f" $Moyenne]
lappend LaSortie "[TailleProteome $TaxId]\t$NbDeltasPourChallenger($TaxId)\t$BelleMoyenne\t$TaxId\t$InfoDu($TaxId)"
}
}
set AvecHisto 0
if {$AvecHisto} {
set LargeurMax 4000
set HauteurMax 5000
set Largeur 3000
set Hauteur 2000
set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur]
global BornesDuGraphe ; set BornesDuGraphe($K) [list -250 0 250 400]
}
set IemeTaxId -1
foreach TaxId $LesTaxIdsChalenger {
set OS [Tax $TaxId Name]
regsub -all " " $OS "_" OSUnderscore
incr IemeTaxId
if {[info exists Cumul]} { unset Cumul }
set MinDelta 9999999
set MaxDelta -9999999
foreach Delta $LesDeltasDeChallenger($TaxId) {
set MinDelta [Mini $Delta $MinDelta]
set MaxDelta [Maxi $Delta $MaxDelta]
}
set IntDelta [expr ($MaxDelta - $MinDelta)/$Echantillonage]
set MinDeltaDe($TaxId) $MinDelta
set MaxDeltaDe($TaxId) $MaxDelta
set IntervalDeltaDe($TaxId) $IntDelta
set MinCase 9999
set MaxCase -9999
foreach Delta $LesDeltasDe($TaxId) {
if {$IntDelta<0.0000001} {
set Case 0
} else {
set Case [expr round(($Delta - $MinDelta)/$IntDelta)]
}
set MinCase [Mini $MinCase $Case]
set MaxCase [Maxi $MaxCase $Case]
if { ! [info exists Cumul($Case)]} { set Cumul($Case) 0 }
incr Cumul($Case)
set Tag($Case) $Delta
foreach Nom [MemoDelta $TaxId $Delta] {
set BeauDelta [format "%6.0f" $Delta]
set BelleMoyenne [format "%6.0f" $Moyenne]
MemoInfo $TaxId $Case "$Nom $BeauDelta $BelleMoyenne"
}
}
set LesX {}
set LesY {}
set LesTags {}
set LaCase [list "#EcartM NF Case TaxId OS Reference_Clade"]
set LesBornesDeCases [NombresEntre $MinCase $MaxCase]
if { ! $UseExpect} {
set LesBornesDeCases [lreverse $LesBornesDeCases]
}
foreach Case $LesBornesDeCases {
if { ! [info exists Cumul($Case)]} { continue }
if { ! [info exists Tag($Case)]} { set Tag($Case) "0.0" }
if { ! [info exists DeltaDeLaCase($Case)]} { set DeltaDeLaCase($Case) "0.0" }
set X [expr $MinDelta + $Case*$IntDelta]
lappend LesX $X
lappend LesY $Cumul($Case)
lappend LesTags "[format %5.0f $X]:$Cumul($Case) $OS"
lappend LaCase "[format %5.0f $X]\t$Cumul($Case)\t$Case\tTaxId:$TaxId\tOS:$OSUnderscore\tReferenceClade:$CladeUnderscore"
}
MemoCase $TaxId LaCase $LaCase
if {$AvecHisto} {
set Couleur [Nuance [expr 1.0*$IemeTaxId/$NbTaxId]]
Graphe $LesX $LesY $K $Couleur "" "" "" "" "HistoDelta" $LesTags "" "BindOnly_oval" $LargeurMax $HauteurMax
} else {
# set F [AfficheListe $LaCase "AvecCase" $OS]
# set B [BoutonneLaFenetre $F "ShowHits" "ShowHitsFromTaxoBlast \[selection get\]"]
# $B configure -background "Magenta"
}
}
if {$GetWhat=="Show"} {
set F [AfficheListe $LaSortie "" "Delta distribution for $Clade"]
set B [BoutonneLaFenetre $F "Distribution" "ShowDeltaDistribution \[selection get\]"]
$B configure -background "Magenta"
}
return $LaSortie
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.