Index by: file name |
procedure name |
procedure call |
annotation
gscope_misynpat.tcl
(annotations | original source)
#rR gscope_misynpat.tcl
#rR Attention j'ai mis un FichierMemo dans MSP
#rR Penser à le mettre à jour si misynpat.sql est mis à jour A FAIRE !!!!!!!!!!!!!!!!!!!!!!
#rR Il faudrait aussi changer MSPFroMac pour ne pas interroger les Macsim à chaque fois
#rR On peut même imaginer de supprimer le CafeDesSciences ...
#rR 2017/04/25 Raymond
proc VerifieAccession {} {
set LesOk {}
set LesKo {}
set LesNe {}
foreach Access [MSP Syn ListOf Accession] {
set AC [GeneQuid UniProt $Access AC]
if {$AC==""} {
Espionne "je ne trouve pas $Access"
lappend LesKo $Access
continue
}
if { ! [regexp -nocase $Access $AC]} {
Espionne "GeneQuid rend $AC pour $Access"
lappend LesNe $Access
continue
}
lappend LesOk $Access
Espionne "$Access est ok"
}
return [list Ok $LesOk Ne $LesNe Ko $LesKo]
}
proc VerifiePubmefInfoAFAIRE {} {
#rR 20210419 Il se peut que les info stockées ne soient pas bonnes
CanalSql [ConnInfoForDatabase MiSynPat]
set LesPkPmid [SqlExec "select pk_biblio,pmid from biblio" "GetList"]
#EspionneL $LesPkPmid
set LesFaux {}
foreach {Pk Pmid} $LesPkPmid {
if {[info exists DejaVu($Pmid)]} {
Espionne "$DejaVu($Pmid) $Pk"
if {[SqlExec "select pk_biblio,pk_synthetase from ln_biblio_synthetase where pk_biblio='$Pk'"]!={}} {
FaireLire "Oups $Pk existe dans ln_biblio_synthetase"
}
lappend LesTrop $Pk
}
lappend DejaVu($Pmid) $Pk
}
}
proc EnleveDoublonsDansMisynpat {} {
#rR 20210405 je ne sais pas pourquoi certaines entrées étaient en doublon !?
CanalSql [ConnInfoForDatabase MiSynPat]
set LesPkPmid [SqlExec "select pk_biblio,pmid from biblio" "GetList"]
#EspionneL $LesPkPmid
set LesTrop {}
foreach {Pk Pmid} $LesPkPmid {
if {[info exists DejaVu($Pmid)]} {
Espionne "$DejaVu($Pmid) $Pk"
if {[SqlExec "select pk_biblio,pk_synthetase from ln_biblio_synthetase where pk_biblio='$Pk'"]!={}} {
FaireLire "Oups $Pk existe dans ln_biblio_synthetase"
}
lappend LesTrop $Pk
}
lappend DejaVu($Pmid) $Pk
}
Espionne Voici les doublons : $LesTrop
foreach Pk $LesTrop {
Espionne $Pk
if { ! [OuiOuNonMemo "J'efface les doublons"]} { continue }
SqlExec "delete from biblio where pk_biblio='$Pk'"
}
return "Bravo"
}
proc ReplaceSequenceInAlignment {FastaToInsert AccessionToRemove {OutputFile ""}} {
global TAddS
if {[regexp "\n" $FastaToInsert]} {
set FastaToInsert [Sauve $FastaToInsert] dans "[TmpFile].tfa"
}
if {$OutputFile==""} { set OutputFile "New.xml" }
set TAdds(KeepClus) 1
set TAddS(File) $FastaToInsert
set TAddS(Position) "afterseq"
set TAddS(seqInsert) $AccessionToRemove
set TAddS(Align) 1
AjouteSeqs
SauveLAlignement "XML" $OutputFile
return $OutputFile
}
proc CreateProttfaDuSite {} {
set LesNouveaux {}
foreach Nom [ListeDesPABs] {
set FicMsp [GscopeFile $Nom prottfaDuSite]
set A [MSP Syn $Nom A]
set S [MSP Syn $Nom SYSTEM]
set HuMi [MSP Syn $A MonAccess]
Espionne
Espionne "$Nom $A $HuMi"
set Accession [AccessionDuMacsimXml $HuMi]
set AccessionVertebrata [AccessionDuMacsimXml $HuMi "/home/ripp/msp/data/alignments/Vertebrata/macsimXmlPoch20170602/${A}mito_Homo.sapi_Poch.xml"]
if {$Accession!=$AccessionVertebrata} { Espionne "$Nom $Accession $AccessionVertebrata ***********************************" }
set SeqGap [TabSFOnDisk $HuMi seq]
regsub -all -nocase {[^A-Z]} $SeqGap "" Seq
set SeqMsp [QueLaSequenceDuTFA $FicMsp]
if { ! [string equal $SeqMsp $Seq]} {
Espionne [string range $SeqMsp 0 80]
Espionne [string range $Seq 0 80]
}
set EnteteMsp [EnteteDuFichierTFA $FicMsp]
set Entete $EnteteMsp
regsub {synthetase [^ ]+$} $Entete "synthetase $Accession" Entete
if {[regexp {synthetase$} $Entete]} { append Entete " $Accession" }
if { ! [string equal $EnteteMsp $Entete]} {
Espionne $EnteteMsp
Espionne $Entete
}
set TFA [SequenceFormatTFA $Seq $Entete "protbrut"]
Espionne $TFA
set FicDuSite [GscopeFile $Nom prottfaDuSite]
if {[OuiOuNonMemo "Je fais les mises à jour des tfa ? "]} { lappend LesNouveaux [Sauve $TFA dans $FicDuSite] }
}
return $LesNouveaux
}
proc AccessionDuMacsimXml {Name {FichierXml ""}} {
if {$FichierXml==""} { set FichierXml "/home/ripp/msp/data/alignments/[string index $Name 0]_WithModules.xml" }
if {[regexp "<seq-name>$Name</seq-name>.+?<seq-info>.+?<accession>(.+?)</accession>" [ContenuDuFichier $FichierXml] Match Accession]} { return $Accession }
regsub mito $Name cyto Name
if {[regexp "<seq-name>$Name</seq-name>.+?<seq-info>.+?<accession>(.+?)</accession>" [ContenuDuFichier $FichierXml] Match Accession]} { return $Accession }
return ""
}
proc CreateLinksToStructures {} {
NousAllonsAuBoulot "[RepertoireDuGenome]/structure"
set LesLIens {}
foreach Nom [ListeDesPABs] {
set System [string tolower [ExtraitInfo $Nom "System:"]]
set Cible "/home/ripp/msp/data/structures/$System"
exec ln -sf $Cible $Nom
Espionne $Cible
lappend LesLiens "$Nom $Cible"
}
OnRevientDuBoulot
}
proc TabSFOnDisk {{Qui ""} {Quoi ""} {ReCreate ""}} {
global TabSFOnDisk Sequences
set ReCreate [string equal -nocase $ReCreate "ReCreate"]
if {$ReCreate} {
if {[info exists TabSFOnDisk]} { unset TabSFOnDisk }
}
if {[info exists TabSFOnDisk($Qui,$Quoi)]} { return $TabSFOnDisk($Qui,$Quoi) }
if {$Quoi=="" && [info exists TabSFOnDisk($Qui)]} { return $TabSFOnDisk($Qui) }
if {[info exists TabSFOnDisk("EstCharge")]} { return "" }
set TabSFOnDisk("EstCharge") 1
set FichierTabSFOnDisk "[MiSynPatDir]/TabSFOnDisk.txt"
if { ! $ReCreate && [FileExists $FichierTabSFOnDisk]} {
array set TabSFOnDisk [ContenuDuFichier $FichierTabSFOnDisk]
set TabSFOnDisk("EstCharge") 1
foreach humi $TabSFOnDisk(ListOf,humi) {
set ::Sequence($humi) $TabSFOnDisk($humi,seq)
}
return [TabSFOnDisk $Qui $Quoi]
}
package require TclOO
package require tdom
package require sqlite3
source "[MiSynPatDir]/src/PageMaker.tcl"
LesDefauts
set LesHumi {}
foreach System [MSP Syn ListOf System] {
set humi [PageMaker $System "LoadTabSF"]
Espionne $humi
set SeqDe($humi) $::Sequences($humi)
lappend LesHumi $humi
array set TabSFOnDisk [array get ::TabSF]
}
set TabSFOnDisk("EstCharge") 1
foreach humi $LesHumi {
set TabSFOnDisk($humi,seq) $SeqDe($humi)
set TabSFOnDisk($humi,exists) 1
lappend TabSFOnDisk(ListOf,humi) $humi
}
Sauve [array get TabSFOnDisk] dans $FichierTabSFOnDisk
return [TabSFOnDisk $Qui $Quoi]
}
proc LesVertebrata {{GetWhat ""}} {
set LesOXOS {}
foreach Ligne [lsort [LesLignesDuFichier "[MiSynPatDir]/data/alignments/Vertebrata/VertebrataListOfOS.txt"]] {
set OS $Ligne
set OX [Tax $OS]
lassign [split $OS " "] Ge Es
set Code [string range $Ge 0 3].[string range $Es 0 3]
lappend LesOX $OX
lappend LesOS $OS
lappend LesOXOS "$OX $OS"
lappend LesOXGEOS "$OX / $Code / $OS"
}
if {$GetWhat=="OX"} { return $LesOX }
if {$GetWhat=="OS"} { return $LesOS }
if {$GetWhat=="OXOS"} { return $LesOXOS }
if {$GetWhat=="OXGEOS"} { return $LesOXGEOS }
return $LesOXOS
}
proc SynthetasesOfVertebrates {} {
#set LesA [split [QuestionDeScience MSP "ret MSP Syn ListOf A"] " "]
set LesA [MSP Syn ListOf A]
foreach A $LesA {
#set ARS [QuestionDeScience MSP "ret MSP Syn $A System"]
set ARS [MSP Syn $A System]
set Nom [RepereBox "Alias: $ARS" AllPlease]
if {[llength $Nom]>1} { FaireLire "$A $ARS tope $Nom"; continue }
Espionne "$A $ARS $Nom"
set BlastFile [GscopeFile $Nom "blastpVertebrata2017"]
Espionne $BlastFile
if {[FileAbsent $BlastFile]} { FaireLire "$A $ARS $Nom pas de blast" ;continue }
set LesBAI($A) {}
set OnAttendChevron 1
set OnAttendQuery 0
foreach Ligne [LesLignesDuFichier $BlastFile] {
if { $OnAttendChevron } {
if { ! [regexp "^>" $Ligne]} { continue }
set LesInfo {}
lappend LesInfo $Ligne
scan $Ligne "%s" BAI
regsub ">" $BAI "" BAI
lappend LesBAI($A) $BAI
set OnAttendQuery 1
set OnAttendChevron 0
continue
}
if {$OnAttendQuery} {
if {[regexp "^Query:" $Ligne]} {
set Info [join $LesInfo " "]
regsub -all { +} [string trim $Info] " " Info
set InfosDe($BAI) $Info
set OnAttendChevron 1
set OnAttendQuery 0
}
lappend LesInfo $Ligne
continue
}
}
foreach BAI $LesBAI($A) {
set Info $InfosDe($BAI)
set Positives ""
regexp {Positives = ([0-9]+/[0-9]+)} $Info Match Positives
set OI [StringApres "OI=" dans $Info]
if {[info exists DejaVu($A,$OI)]} { continue }
set DejaVu($A,$OI) 1
lassign [split $Info "="] Debut
regsub {^[^ ]+ } $Debut "" DE
regsub " OS" $DE "" DE
regexp { ([0-9]+/[0-9]+)} $Info Match Positives
Espionne "$A $OI $Positives $DE"
}
}
}
proc AliFromOiPoch {{ListOfA ""}} {
set RepSrcXml "/home/poch"
set RepDesXml "/home/ripp/msp/data/alignments/Vertebrata/macsimXmlPoch20170602"
set LesElus {}
if {$ListOfA==""} { set ListOfA [MSP Syn ListOf A] }
foreach A $ListOfA {
set Nom [MSP Syn $A Nom]
set Name "${A}mito_Homo.sapi"
set Accession [MSPFroMac $Nom TDesAccess $Name]
set NomHs [QuestionDeScience "EHomsa" "ret NIAG $Accession N"]
if {$NomHs==""} {
set NomHs [QuestionDeScience "EHomsa" "ret NIAG SY${A}M_HUMAN N"]
}
if {$NomHs==""} {
set NomHs [QuestionDeScience "EHomsa" "ret NIAG SY${A}_HUMAN N"]
}
Espionne "$A $Accession $NomHs"
# Espionne [QuestionDeScience "EHomsa" "ret ExtraitInfo $NomHs"]
if {$NomHs==""} { continue }
set Queue "${Name}_Poch.xml"
set FichierSrc "$RepSrcXml/$Queue"
Espionne $FichierSrc
set LeXml [LesLignesDuFichier $FichierSrc]
set LeNew {}
set OX ""
if {[info exists DejaVu]} { unset DejaVu }
set LaSequenceCourante {}
set DansSequence 0
set OnGarde 1
if {$A=="G"} { set Name "P41250" }
foreach Ligne $LeXml {
if {[regexp "</sequence" $Ligne]} {
lappend LaSequenceCourante $Ligne
if {$OnGarde} {
LConcat LeNew $LaSequenceCourante
}
set LaSequenceCourante {}
set DansSequence 0
continue
}
if {[regexp "<sequence" $Ligne]} {
lappend LaSequenceCourante $Ligne
set DansSequence 1
set OnGarde 1
continue
}
if { ! $DansSequence } {
lappend LeNew $Ligne
continue
}
set SeqName ""
if {[regexp {<seq\-name>([^<]+)</seq\-name>} $Ligne Match SeqName]} {
if {$A!="G" && $SeqName==$Name} { set OnGarde 0 }
if {$A=="G" && $SeqName=="Gmito_Homo.sapi"} { set OnGarde 0 }
if {$SeqName!="" && ($SeqName!=$Name || $SeqName=="P41250") } {
set R [QuestionDeScience GeneQuid "ret UniprotData $SeqName ID,GN,OX"]
scan $R "%s" Id
set Gn [StringApres "Name=" dans $R]
set OX [IntegerApres "NCBI_TaxID=" dans $R]
lappend LesOX($A) $OX
lappend DejaVu($A,$OX) "$SeqName : \n$R"
set OS [OiCodeForDomain Eukaryota $OX OS]
lassign [split $OS " "] Ge Es
set Es [string trim $Es "."]
set Code [string totitle [string range $Ge 0 3]].[string tolower [string range $Es 0 3]]
Espionne ""
Espionne $OnGarde
Espionne "$Id $Gn $Ligne"
if {[regexp -nocase "^${A}ARS2" $Gn] || ([regexp -nocase {^[GK]ARS} $Gn] && $SeqName!="P41250") || [regexp -nocase "^SY${A}M" $Id]} {
if {[regexp {^([^_]+)_(.+)$} $Id Match Ac Os]} {
set XmitoGenrespe ${A}mito_$Code
if {[info exists DejaVu($XmitoGenrespe)]} { append XmitoGenrespe 2 }
set DejaVu($XmitoGenrespe) 1
set Ligne "<seq-name>$XmitoGenrespe</seq-name>"
}
} elseif {[regexp -nocase "^SY${A}C" $Id]} {
set XcytoGenrespe ${A}cyto_$Code
if {[info exists DejaVu($XcytoGenrespe)]} { append XcytoGenrespe 2 }
set DejaVu($XcytoGenrespe) 1
set Ligne "<seq-name>$XcytoGenrespe</seq-name>"
} else {
}
#rR Traitement spécial pour GARS car on ne sait pas s'ils sont cyto ou mito
Espionne $Ligne
if {$A=="G" && ! [regexp "Homo.sapi" $Ligne] && [regexp {<seq\-name>G(cyto|mito)_} $Ligne]} {
regsub {<seq\-name>G(cyto|mito)_} $Ligne "<seq-name>G_" Ligne
}
Espionne "regexp {<seq\-name>P41250</seq\-name>} $Ligne"
if {$A=="G" && [regexp {<seq\-name>P41250</seq\-name>} $Ligne]} {
regsub {<seq\-name>P41250</seq\-name>} $Ligne "<seq-name>Gcyto_Homo.sapi</seq-name>" Ligne
}
if {0 && $A=="G" && [regexp {<seq\-name>A0A091E8Q8</seq\-name>} $Ligne]} {
regsub {<seq\-name>A0A091E8Q8</seq\-name>} $Ligne "<seq-name>Gmito_Homo.sapi</seq-name>" Ligne
}
}
}
if {[regexp {<seq\-data>([^<]+)</seq\-data>} $Ligne Match SeqGap]} {
set SeqGap [string toupper $SeqGap]
regsub -all {[^A-Z]} $SeqGap "" Seq
set SeqDe($A,$OX) $Seq
lappend LesAOXDeSeq($Seq) "$A,$OX"
lappend LesSeq $Seq
}
lappend LaSequenceCourante $Ligne
}
foreach Seq $LesSeq {
if {[llength LesAOX($Seq)]>1} {
Espionne "SequencesDoublons"
Espionne [join LesAOXDeSeq($Seq) " "]
}
}
lappend LesErreurs ""
set MessageEntete "$A **************************** "
Espionne $MessageEntete
set LesOX($A) [lsort -unique $LesOX($A)]
foreach OX $LesOX($A) {
if {[llength $DejaVu($A,$OX)]>1} {
lappend LesErreurs ""
lappend LesErreurs $MessageEntete
set Message [join $DejaVu($A,$OX) "\n\n"]
lappend LesErreurs $Message
Espionne $Message
}
}
lappend LesElus [SauveLesLignes $LeNew dans $RepDesXml/$Queue]
}
SauveLesLignes $LesErreurs dans $RepDesXml/Doubles.txt
return $LesElus
}
proc AliFromOi {} {
set RepSrcXml "/genomics/link/EHomsa/macsimXmlVertebrata2017"
set RepSrcRsf "/genomics/link/EHomsa/macsimRsfVertebrata2017"
set RepDesXml "/home/ripp/msp/data/alignments/Vertebrata/macsimXml"
set RepDesRsf "/home/ripp/msp/data/alignments/Vertebrata/macsimRsf"
set LesElus {}
foreach A [MSP Syn ListOf A] {
set Nom [MSP Syn $A Nom]
set Name "${A}mito_Homo.sapi"
set Accession [MSPFroMac $Nom TDesAccess $Name]
set NomHs [QuestionDeScience "EHomsa" "ret NIAG $Accession N"]
if {$NomHs==""} {
set NomHs [QuestionDeScience "EHomsa" "ret NIAG SY${A}M_HUMAN N"]
}
if {$NomHs==""} {
set NomHs [QuestionDeScience "EHomsa" "ret NIAG SY${A}_HUMAN N"]
}
Espionne "$A $Accession $NomHs"
Espionne [QuestionDeScience "EHomsa" "ret ExtraitInfo $NomHs"]
if {$NomHs==""} { continue }
set Xml [ContenuDuFichier $RepSrcXml/$NomHs]
regsub -all $NomHs $Xml $Name Xml
Sauve $Xml dans $RepDesXml/$Name.xml
file copy -force $RepSrcXml/$NomHs $RepDesXml/$NomHs.xml
foreach Rsf [glob -nocomplain $RepSrcRsf/$NomHs*] {
file copy -force $Rsf $RepDesRsf/
set Queue [file tail $Rsf]
regsub $NomHs $Queue $Name Queue
file copy -force $Rsf $RepDesRsf/$Queue
}
lappend LesElus "$A $Nom $Name"
}
return $LesElus
}
proc FromTabSFOnDisk {{Qui ""} {Quoi ""}} {
#rR Pour tester TabSFOnDisk à partir de gscope
global TabSFOnDisk
if {[info exists TabSFOnDisk($Qui,$Quoi)]} { return $TabSFOnDisk($Qui,$Quoi) }
if {[info exists TabSFOnDisk("EstCharge")]} { return "" }
set TabSFOnDisk("EstCharge") 1
set FichierTabSFOnDisk "[MiSynPatDir]/TabSFOnDisk.txt"
if { ! [FileExists $FichierTabSFOnDisk]} { return "" }
array set TabSFOnDisk [ContenuDuFichier $FichierTabSFOnDisk]
set TabSFOnDisk("EstCharge") 1
return [FromTabSFOnDisk $Qui $Quoi]
}
proc RajouteMut3LAuTitre Titre {
set I 0
while {[regexp -start $I -indices { [A-Z][0-9]+[A-Z]( |$)} $Titre Indices]} {
lassign $Indices D F
set Mut [string range $Titre $D $F]
set I $F
set Mut3L [Mut3L $Mut]
set Titre [string replace $Titre $D $F " $Mut $Mut3L "]
}
return $Titre
}
proc Mut3L A123B {
set A123B [string trim $A123B]
if { ! [regexp {^([A-Z])([0-9]+)([A-Z])$} $A123B Match W Pos M]} { return "" }
set Wil [string totitle [UT $W]]
set Mut [string totitle [UT $M]]
if {$M=="X"} { set Mut "*" }
set Mut3L "p.$Wil$Pos$Mut"
return $Mut3L
}
proc ListeOrgMsp {} {
#rR j'ai pas vraiment fini .. .Marie l'a fait à la main voir SuppTable1
array set Domaines [list cyanobacterie cyanobacteria bacterie bacteria archae archae eukaryotes eukaryota alpha-proteobacterie alpha-proteobacteria]
foreach Ligne [LesLignesDuFichier "[MiSynPatDir]/article/ListeMarie.txt"] {
set LesMots [LesMotsDuTexte $Ligne]
set Ligne [join $LesMots " "]
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
regsub {\(.+$} $Ligne "" Ligne
regsub {^/[^ ]+ } $Ligne "" Ligne
set Ligne [string trim $Ligne]
Espionne "=$Ligne="
if {[info exists Domaines($Ligne)]} {
set Domaine $Domaines($Ligne)
lappend LeNew ""
lappend LeNew $Domaine
continue
}
set OS $Ligne
Espionne "=$OS="
if {$OS=="Brachydanio rerio"} { set OS "Danio rerio" }
regsub "Methanococcus jannaschii" $OS "Methanocaldococcus jannaschii" OS
regsub "Methanobacterium thermoautotrophicum" $OS "Methanothermobacter thermautotrophicus" OS
regsub "Borrelia burgdorferi" $OS "Borreliella burgdorferi" OS
regsub "Chlamydophila pneumoniae" $OS "Chlamydia pneumoniae" OS
regsub "Chlorobium tepidum" $OS "Chlorobaculum tepidum" OS
set OXde(Dehalococcoides_ethenogenes) [Tax "Dehalococcoides mccartyi"]
regsub { sp$} $OS " sp." OS
regsub -all " " $OS "_" OSU
if {[info exists OXde($OSU)]} {
set OX $OXde($OSU)
} else {
set OX [Tax $OS]
}
set E ""
scan $OS "%s %s" G E
set Code "[string range $G 0 3].[string range $E 0 3]"
if {$Code=="Nost."} { set Code "Anab.sp" }
if {$Code=="Syne."} { set Code "Syne.sp" }
lappend LeNew "$OX\t$Code\t$OS"
}
return $LeNew
exit
foreach Ligne [LesLignesDuFichier "[MiSynPatDir]/article/ListeOG.txt"] {
set LesMots [LesMotsDuTexte $Ligne]
set Code [lindex $LesMots 0]
set Domaine [lindex $LesMots end]
set OX [lindex $LesMots end-1]
set OS [join [lrange $LesMots 1 end-2] " "]
set OS [string trim $OS " ."]
regsub {a\-proteobact\.} $Domaine "alpha-proteobacteria" Domaine
regsub {bact\.} $Domaine "bacteria" Domaine
regsub {eukar\.} $Domaine "eukaryota" Domaine
#Espionne "$Code $OX $Domaine $OS"
if {[Tax $OX]!=$OS} { Espionne "$OX [Tax $OX]!=$OS" }
if {[Tax $OS]!=$OX} { Espionne "$OS [Tax $OS]!=$OX" }
}
exit
}
proc VerifieLesMutations {} {
set LesMauvais {}
foreach Nom [ListeDesPABs] {
set Seq1 x[string toupper [QueLaSequenceDuFichierTFA [GscopeFile $Nom "prottfa"]]]
set Seq1 x[SeqMac $Nom]
set A [NomDeMSP $Nom A]
set LesMutations [lsort -unique [concat [MSP Mut $A ListOfV1] [MSP Mut $A ListOfV2]]]
foreach A123B $LesMutations {
if { ! [regexp {([A-Z])([0-9]+)([A-Z])} $A123B Match W P M]} { FaireLire "$Nom $A $A123B merde !"; continue }
if {$W=="X"} { continue }
if {[string index $Seq1 $P]!=$W} {
set Message "$Nom $A en $A123B [string index $Seq1 $P]!=$W [string range $Seq1 $P-5 $P+5]"
Espionne $Message
lappend LesMauvais $Message
}
}
}
return $LesMauvais
}
proc MitoHs Qui {
#rR Rend le Amito_Homo.sapi en fonction de toute info qui y fait référence : A Ala MSP01 ...
global MitoHs
set A [NomDeMSP $Qui A]
if {[regexp {^[A-Z]$} $A]} { return "${A}mito_Homo.sapi" }
return ""
}
proc SeqMac {Nom {D ""} {F ""}} {
#rR ici onprend la sequence par MspFroMac
#rR Elle est aussi disponible pas MSP Syn Y SeqWithGap (ou SeqWithoutGap)
set SeqGap [MSPFroMac $Nom Sequences [MitoHs $Nom]]
set SeqGap [string toupper $SeqGap]
regsub -all -nocase {[^a-z]} $SeqGap "" SeqMac
if {$F==""} { set F $D }
if {$D!=""} { return [string range x$SeqMac $D $F] }
return $SeqMac
}
proc VerifieCoherence {} {
foreach Nom [ListeDesPABs] {
set A [NomDeMSP $Nom A]
set MitoHs [MitoHs $Nom]
set SeqMac [SeqMac $Nom]
set SeqTfa [string toupper [QueLaSequenceDuFichierTFA [GscopeFile $Nom "prottfa"]]]
if {[string equal $SeqMac $SeqTfa]} { continue }
Espionne "$Nom $A Mac $SeqMac"
Espionne
Espionne "$Nom $A Tfa $SeqTfa"
FaireLire $Nom
}
}
proc TLN {} {
set Xml [ContenuDuFichier "/home/ripp/msp/exemp.txt"]
if {[regexp {LastName.Kars} $Xml Match]} { Espionne "$Match"; set Saute($Pmid) 1 }
exit
}
proc SP {{Menage ""} {Test ""}} {
#rR Attention InfoPubmed fait une mémorisation en fonction du MD5 de LesPmids
package require tdom
set Test [string equal -nocase $Test "Test"]
if {$Test} {
set LesT [SurveillancePubmed GetResult]
set LesA [SurveillancePubmed GetResult AllFields]
set LesTuA [ListsUnion $LesT $LesA]
set LesTiA [ListsIntersection $LesT $LesA]
set LesTnA [ListsComplement $LesT $LesA]
set LesAnT [ListsComplement $LesA $LesT]
# set LesPmids [concat [lrange $LesAnT 0 5] [lrange $LesTiA 0 5]]
set LesPmids [lrange $LesA 0 end]
set LesDejaVu [SqlExecForDatabase MiSynpat "select pmid from biblio" "GetList"]
foreach L [list LesTuA LesTiA LesTnA LesAnT LesDejaVu] {
Espionne "$L [llength [set $L]]"
}
} else {
set LesPmids [SqlExecForDatabase MiSynPat "select pmid from biblio where accepted=-1 OR accepted=2" "GetList"]
}
set Menage [string equal -nocase $Menage "Menage"]
set LeH {}
lappend LeH "<!DOCTYPE html>"
lappend LeH "<html>"
lappend LeH " <head>"
lappend LeH " <meta charset='UTF-8'>"
lappend LeH " </head>"
lappend LeH " <body>"
lappend LeH " <div style='width:60%; margin-left:20%'>"
lappend LeH "<h5>"
if {$Test} {
lappend LeH "Bonjour Marie.<br/>"
lappend LeH "A bientôt :)<br/>"
lappend LeH " Raymond"
lappend LeH "</h5>"
} else {
lappend LeH "Bonjour.<br/>"
lappend LeH "Cette page affiche en clair tous les pmids à traiter."
lappend LeH "A bientôt :)<br/>"
lappend LeH " Raymond"
lappend LeH "</h5>"
}
set NbNew 0
if {0 && $Test} {
set TexteXml [eSummaryREST pubmed $LesPmids "" "GetXml"]
while {[set Xml [ValeurDeLaBalise "DocSum" TexteXml]]!=""} {
set Pmid ""
regexp {<Id>([0-9]+)</Id>} $Xml Match Pmid
Espionne $Pmid
if {[regexp 27625683 $Xml]} { Espionne $Xml }
if {[regexp {Kars[ \,]*Turkey} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
}
}
if {0 && $Test} {
set LesKarsTurkey [split [ContenuDuFichier "/home/ripp/msp/KarsTurkey.txt"] "\n "]
foreach Pmid $LesKarsTurkey {
set Saute($Pmid) 1
}
}
foreach Pmid $LesPmids {
Espionne $Pmid
if {[info exists Saute($Pmid)] } { continue }
if {$Menage} {
set Xml [ContenuDuFichier "https://www.ncbi.nlm.nih.gov/pubmed/$Pmid/&format=text?report=xml&format=text"]
#Espionne $Xml
if {[regexp {Kars[ \,]*TR} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
if {[regexp {Kars[ \,]*Turkey} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
if {[regexp {Kafkas[^\n]+Kars} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
if {[regexp {Hospital[^\n]+Kars} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
if {[regexp {LastName[^\n]+Kars} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
if {[regexp {LastName[^\n]+Gars} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
}
if {[info exists Saute($Pmid)] } { continue }
set DejaVu ""
set ColorDejaVu "red"
set Origin ""
set ColorOrigin "green"
if {$Test} {
if {[lsearch $LesDejaVu $Pmid]<0} {
set DejaVu "Is not yet in Database"
set ColorDejaVu "red"
} else {
set DejaVu "Is in Database"
set ColorDejaVu "green"
continue
}
if {[lsearch $LesT $Pmid]<0} {
set Origin "Query in Title/Abstract (should be in the database)"
set ColorOrigin "green"
} else {
set Origin "Query in All Fields"
set ColorOrigin "red"
}
}
set Title [InfoPubmed $LesPmids $Pmid Title]
set Abstract [InfoPubmed $LesPmids $Pmid Abstract]
regsub -all "\n" $Abstract "<br/>\n" Abstract
lappend LeH "<br/>"
lappend LeH "<br/>"
lappend LeH "<a target='_blank' href='https://www.ncbi.nlm.nih.gov/pubmed/$Pmid'>$Pmid</a> <span style='color:$ColorOrigin;'>$Origin</span> <span style='color:$ColorDejaVu;'>$DejaVu</span>"
lappend LeH "<br/>"
lappend LeH "<h4><i>$Title</i></h4>"
lappend LeH $Abstract
lappend LeH ""
incr NbNew
}
Espionne $NbNew
lappend LeH " </div>"
lappend LeH " </body>"
lappend LeH "<html>"
set Html [join $LeH "\n"]
set Query [SurveillancePubmed GetQuery]
foreach {Bidon Hit } [split $Query "\""] {
if {[regexp {^[0-9]+$} $Hit]} { continue }
if { ! [regexp -nocase {^[a-z0-9]+$} $Hit]} { continue }
lappend LesHits $Hit
}
Espionne $LesHits
foreach Hit $LesHits {
regsub -nocase -all $Hit $Html "<span style='background-color:lightgreen';>&</span>" Html
}
regsub -nocase -all mito $Html "<span style='background-color:pink';>&</span>" Html
regsub -nocase -all trna $Html "<span style='background-color:pink';>&</span>" Html
regsub -nocase -all synthetase $Html "<span style='background-color:pink';>&</span>" Html
if {$Menage} { return "" }
return $Html
}
proc InfoPubmed {Pmids {Qui ""} {Quoi ""}} {
global InfoPubmed
if {[regexp {[^0-9]} $Pmids]} {
regsub -all {[^0-9]} $Pmids " " Pmids
set Pmids [split [string trim $Pmids] " "]
}
if {[info exists InfoPubmed($Pmids,$Qui,$Quoi)]} { return $InfoPubmed($Pmids,$Qui,$Quoi) }
if {[info exists InfoPubmed($Pmids,"EstCharge")]} { return "" }
set InfoPubmed($Pmids,"EstCharge") 1
package require md5
set MD5 [::md5::md5 -hex $Pmids]
set Fic "/home/ripp/msp/sp_$MD5"
if {[file exists $Fic]} {
array set InfoPubmed [ContenuDuFichier $Fic]
return [InfoPubmed $Pmids $Qui $Quoi]
}
set InfoPubmed($Pmids,All,Title) {}
set InfoPubmed($Pmids,All,Abstract) {}
set InfoPubmed($Pmids,All,All) {}
set Linfo [eFetchREST pubmed $Pmids]
array set Tinfo $Linfo
foreach Pmid $Pmids {
if {[info exists Tinfo]} {
#unset Tinfo
}
#set Linfo [eFetchREST pubmed $Pmid]
#array set Tinfo $Linfo
# #parray Tinfo
set InfoPubmed($Pmids,$Pmid,All) {}
foreach {K V} [array get Tinfo] {
lappend InfoPubmed($Pmids,$Pmid,All) "$K=$V"
}
set InfoPubmed($Pmids,$Pmid,All) [join $InfoPubmed($Pmids,$Pmid,All) "\n"]
if {! [info exists Tinfo($Pmid,Title)] && ! [info exists Tinfo($Pmid,Abstract)] && ! [info exists Tinfo($Pmid,PubYear)]} {
lappend InfoPubmed($Pmids,ListOf,Ko) $Pmid
continue
}
lappend InfoPubmed($Pmids,ListOf,Ok) $Pmid
set InfoPubmed($Pmids,$Pmid,Title) $Tinfo($Pmid,Title)
set InfoPubmed($Pmids,$Pmid,Abstract) $Tinfo($Pmid,Abstract)
set InfoPubmed($Pmids,$Pmid,PubYear) $Tinfo($Pmid,PubYear)
set InfoPubmed($Pmids,$Pmid,PubMonth) $Tinfo($Pmid,PubMonth)
set InfoPubmed($Pmids,$Pmid,LAuthors) $Tinfo($Pmid,LAuthors)
lappend InfoPubmed($Pmids,All,Title) "$Pmid $InfoPubmed($Pmids,$Pmid,Title)"
lappend InfoPubmed($Pmids,All,Abstract) "$Pmid $InfoPubmed($Pmids,$Pmid,Abstract)"
lappend InfoPubmed($Pmids,All,All) "$Pmid $InfoPubmed($Pmids,$Pmid,All)"
}
set InfoPubmed($Pmids,All,Title) [join $InfoPubmed($Pmids,All,Title) "\n"]
set InfoPubmed($Pmids,All,Abstract) [join $InfoPubmed($Pmids,All,Abstract) "\n"]
set InfoPubmed($Pmids,All,All) [join $InfoPubmed($Pmids,All,All) "\n"]
#rR Sauve [array get InfoPubmed] dans $Fic
return [InfoPubmed $Pmids $Qui $Quoi]
}
proc MiseAJourDatesBiblio {{pmid ""}} {
set Where ""
if {$pmid!=""} { set Where "where pmid=$pmid" }
set LesRecords [SqlExecForDatabase "MiSynPat" "select pmid,datem,datey,pk_biblio from biblio $Where" "GetListOfList"]
set NbTot 0
set NbOk 0
set NbEmpty 0
set NbADiff 0
set LesUpdate {}
set Ltmp [lmap x $LesRecords {lindex $x 0}]
set Lrest [eSummaryREST pubmed $Ltmp]
array set T $Lrest
foreach Record $LesRecords {
lassign $Record P M A Pk
#set Lrest [eSummaryREST pubmed $P]
#array set T $Lrest
if { ! [info exists T($P,PubDate)]} {
continue
}
incr NbTot
set PubDate $T($P,PubDate)
Espionne $PubDate
lassign [split $PubDate " -"] PA PM
Espionne "$A=$PA $PM=$M="
if {$A!="" && $A!=$PA} {
incr NbADiff ; continue
}
if {$M==$PM && $A==$PA} {
incr NbOk ; continue
}
if {$M=="" || $A==""} {
if {[Month1to12 $PM]!=0 } {
set Update "update biblio set datem='$PM', datey='$PA' where pk_biblio=$Pk"
lappend LesUpdate $Update
}
incr NbEmpty
} else {
incr NbDiff
}
Espionne "$P $A = $PubDate = $M"
}
Espionne "[llength $LesRecords] $NbADiff $NbTot $NbOk $NbEmpty"
set LesUpdateAFaire [split [AfficheListe $LesUpdate "AvecRetour"] "\n"]
foreach Update $LesUpdateAFaire {
Espionne $Update
#SqlExecForDatabase "MiSynpat" $Update
}
return $LesUpdate
}
proc TriParMoisAnnee {R1 R2} {
lassign $R1 M1 A1
if {$M1==""} { set M1 Juin }
lassign $R2 M2 A2
if {$M2==""} { set M2 Juin }
return [CompareDate "$M1 $A1" "$M2 $A2"]
}
proc MspBiblioGrowth {{GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "GetCouplesDates" }
set LesRecords [SqlExecForDatabase "MiSynPat" "select datem,datey,pk_biblio,accepted,pmid from biblio where accepted=1" "GetListOfList"]
set LesRecords [lsort -command TriParMoisAnnee $LesRecords]
set LesMA {}
set FirstA 2007
set FirstM 0
set MaxSince 0
foreach Record $LesRecords {
lassign $Record M A P V Pmid
Espionne "$Record"
if {$V<1} { continue }
if {$A==""} { set A 2012 }
if {$M==""} { set M "Jun" }
if {[regexp {^[0-9]+$} $M]} {
#rR si le mois est donné en chifre ... on enleve les leading 0"
set N $M
regsub {^0+} $N "" N
} else {
set N [Month1to12 $M]
}
# if {$FirstA==""} { set FirstA $A ; set FirstM $N }
set Since [expr ($A-$FirstA)*12 + $N-$FirstM]
set MaxSince [Maxi $MaxSince $Since]
incr Occu($Since)
set DateDe($Since) "$A-[format %2.2d $N]"
# set DateDe($Since) "$M-$A"
}
set LesSince {}
foreach Since [NombresEntre 0 $MaxSince] {
if { ! [info exists Occu($Since)]} {
set Occu($Since) 0
}
lappend LesSince $Since
}
set Cumul 0
set LesCouplesDates {}
foreach Since $LesSince {
lappend LesOccu $Occu($Since)
incr Cumul $Occu($Since)
lappend LesCouples "\[$Since, $Cumul\]"
if {[info exists DateDe($Since)]} { lappend LesCouplesDates "\['$DateDe($Since)', $Cumul\]" }
lappend LesCumul $Cumul
}
EspionneL $LesCouplesDates
set CouplesDates [join $LesCouplesDates ","]
if {$GetWhat=="GetCouplesDates"} { return $CouplesDates }
set Couples [join $LesCouples ","]
Espionne "\[\[$CouplesDates\]\]"
Espionne "\[\[$Couples\]\]"
Espionne $LesSince
Espionne $LesOccu
return [Graphe $LesSince $LesCumul]
}
proc MspRuns {} {
set LeStatus {}
set Url "http://misynpat.org/misynpat/"
set Top [FromProtUrl $Url 2316apriseparcoeur 1623100Raphael]
if {$Top!=[ContenuDuFichier "/home/ripp/msp/HtmlModeles/Top.html"]} {
# Espionne "Merde Top"
lappend LeStatus 0
} else {
# Espionne "Ok Top"
lappend LeStatus 1
}
set Url "http://misynpat.org/misynpat/ConservationDesMutationsEtStat.rvt?name=DARS2"
set Mut [FromProtUrl $Url 2316apriseparcoeur 1623100Raphael]
if {$Mut!=[ContenuDuFichier "/home/ripp/msp/HtmlModeles/Mut.html"]} {
# Espionne "Merde Mut"
lappend LeStatus 0
} else {
# Espionne "Ok Mut"
lappend LeStatus 1
}
set Status [join $LeStatus ""]
if {[regexp "0" $Status]} {
send_simple_message "raymond.ripp@unistra.fr" localhost "MspRuns with status $Status" "hihi" "misynpat@lbgi.fr"
}
return "MspRuns with status $Status"
}
proc CreateLinkInMacsimXmlMisynpat {} {
set XmlDir "[MiSynPatDir]/data/alignments"
set RepMacimXml "[RepertoireDuGenome]/macsimXml_Misynpat"
file mkdir $RepMacimXml
NousAllonsAuBoulot $RepMacimXml
foreach Nom [ListeDesPABs] {
set A [ExtraitInfo $Nom A]
set XmlFic "$XmlDir/${A}_WithModules.xml"
Espionne $XmlFic
exec ln -sf $XmlFic $Nom
}
OnRevientDuBoulot
return
}
proc OuSontLesMutations {{GetWhat ""} {AllOrA ""} {Conservation ""} {Order ""} {Action ""}} {
#rR-Permet de voir en gros comment sont réparties les mutations
#rR-OuSontLesMutations Help (Help ... W means Wildtype (source), M means Mutation (destination))
#rR OuSontLesMutations WM (See howmany times each AA appears as source and destination of a mutation)
#rR OuSontLesMutations Types (See howmany times each Type of AA appears as source and destination of a mutation)
#rR OuSontLesMutations
#rR OuSontLesMutations Modules All (Number of mutations per structural module for all systems)
#rR OuSontLesMutations FromWtoM All (Number of occurrences of each substitution for all systems)
#rR OuSontLesMutations FromWtoM All All-Cons (Number of occurrences of each substitution for all systems on conserved positions)
#rR OuSontLesMutations FromWtoM All IdenCons (Number of occurrences of each substitution for all systems on 100/100 conserved positions)
#rR OuSontLesMutations FromWtoM All ConsCons (Number of occurrences of each substitution for all systems on 80/100 conserved positions)
#rR OuSontLesMutations FromWtoM All SimiCons (Number of occurrences of each substitution for all systems on physicochemically conserved positions)
#rR OuSontLesMutations FromWtoM All NoCons (Number of occurrences of each substitution for all systems on non conserved positions)
#rR OuSontLesMutations
#rR OuSontLesMutations Modules D (Number of mutations per structural module) for Any AA
#rR OuSontLesMutations FromWtoM D (Number of occurrences of each substitution) for Any AA
#rR OuSontLesMutations FromWtoM D All-Cons (Number of occurrences of each substitution on conserved positions) for Any AA
#rR OuSontLesMutations FromWtoM D IdenCons (Number of occurrences of each substitution on 100/100 conserved positions) for Any AA
#rR OuSontLesMutations FromWtoM D ConsCons (Number of occurrences of each substitution on 80/100 conserved positions) for Any AA
#rR OuSontLesMutations FromWtoM D SimiCons (Number of occurrences of each substitution physicochemically conserved positions) for Any AA
#rR OuSontLesMutations FromWtoM D NoCons (Number of occurrences of each substitution on non conserved positions) for Any AA
if {$Action=="-"} { set Action "" }
if {$Order=="-"} { set Order "" }
if {$Conservation=="-"} { set Conservation "" }
if {$AllOrA=="-"} { set AllOrA "" }
if {$GetWhat=="-"} { set GetWhat "" }
if {$Action==""} { set Action "Show" }
if {[regexp -nocase "ars" $AllOrA]} {
set AllOrA [MSP Syn [string toupper $AllOrA] A]
}
if {$GetWhat==""} { set GetWhat "Help" }
if {$GetWhat=="Help"} {
set LeHelp {}
set LeHelpText {}
foreach Ligne [split [info body OuSontLesMutations] "\n"] {
if { ! [regexp "#rR +OuSont" $Ligne]} { continue }
regsub "#rR " $Ligne "" Text
lappend LeHelpText $Text
regsub "#rR " $Ligne {http://lbgi.fr/wscoperr?MSP\&} Ligne
regsub -all { +} $Ligne " " Ligne
set Ligne [string trim $Ligne]
set Ref $Ligne
regsub { +\(.*$} $Ref "" Ref
regsub -all " " $Ref {\&} Ref
lappend LeHelp $Ligne
regsub {^[^&]+&} $Ligne "" Text
lappend LesRefText $Ref $Text
}
if {[PourWscope]} {
if {$Action=="GetAsText"} { return [join $LeHelpText "\n"] }
return [Html_ListOfRefs $LesRefText "<center><h3>Où sont les mutations ?</h3></center>"]
}
if {$Action=="GetAsText"} { return [join $LeHelp "\n"] }
return [AfficheListe $LeHelp]
}
#rR On met ConsLocal car on a aussi stocké les conservations en coordonnées locales
set ConsLocal $Conservation
if {$ConsLocal!=""} {
regsub -nocase "NoCons" $ConsLocal "No" ConsLocal ;#rR car il serait logique de pouvoir mettre NoConservation
regsub -nocase "AllCons" $ConsLocal "All" ConsLocal ;#rR car il serait logique de pouvoir mettre AllConservation
if {[regexp -nocase {^(Iden|Simi|Cons|No)} $ConsLocal Match]} {
set ConsLocal "[string totitle $Match]Local"
} else {
set ConsLocal "AllLocal"
}
}
if {$AllOrA==""} { set AllOrA "All" }
#rR WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM
if {$GetWhat=="WM"} {
set LaSortie {}
set AllA $AllOrA
if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
foreach A $AllA {
set NbW [MSP Mut $A All-WCount]
set NbM [MSP Mut $A All-MCount]
lappend LaSortie [format "%s %2d %2d" $A $NbW $NbM]
}
if {$Action=="GetAsText"} { return [join $LaSortie "\n"] }
return [AfficheListe $LaSortie "" $GetWhat]
}
#rR Types Types Types Types Types Types Types Types Types Types Types Types Types Types Types
set LaSortie {}
foreach Type [AAType Types] {
set M 0
set NbW 0
set NbM 0
set Size 0
set Compo ""
foreach A [AAType $Type] {
incr Size
incr NbW [MSP Mut $A All-WCount]
incr NbM [MSP Mut $A All-MCount]
append Compo $A
}
set PcW [expr $NbW/$Size]
set PcM [expr $NbM/$Size]
lappend LaSortie [format "%2d %2d %-10s %-6s" $NbW $NbM $Type $Compo]
}
if {$GetWhat=="Types"} {
if {$Action=="GetAsText"} { return [join $LaSortie "\n"] }
return [AfficheListe $LaSortie "" "Types"]
}
#rR Modules Modules Modules Modules Modules Modules Modules Modules Modules Modules Modules
set LaSortie {}
if {[info exists NbMutIn]} { array unset NbMutIn }
set AllA $AllOrA
if {$AllOrA=="All"} { set AllA [MSP Syn ListOf A] }
foreach A $AllA {
foreach Name [lsort [MspModule $A ListOf Name]] {
if { ! [info exists NbMutIn($Name)]} { set NbMutIn($Name) 0 ; set MutIn($Name) {}}
foreach Pos [lsort -unique [MSP Mut $A ListOfPos]] {
foreach Deb [MspModule $A $Name Deb] Fin [MspModule $A $Name Fin] {
if {$Deb<=$Pos && $Pos<=$Fin} {
incr NbMutIn($Name)
lappend MutIn($Name) $A
}
}
}
}
}
foreach K [lsort [array names NbMutIn]] {
set V $NbMutIn($K)
set As {}
set AAListe ""
if {$AllOrA=="All" && $NbMutIn($K)>0} {
set As [lsort -unique $MutIn($K)]
set AAListe "([join $As {}])"
}
lappend LaSortie [format "%3d %s" $V "mutations in $K $AAListe"]
}
set LaSortie [lsort -decreasing $LaSortie]
if {$GetWhat=="Modules"} {
if {$Action=="GetAsText"} { return [join $LaSortie "\n"] }
return [AfficheListe $LaSortie "" "Modules_${AllOrA}"]
}
#rR FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM
set LaSortie {}
set LesStat {}
if {[regexp -nocase "Alpha" $Order]} {
set LesL [MSP All ListOf A]
} else {
set LesL [AAType ListOfA]
}
set LesC $LesL
lappend LesC "X"
set LaLigne3L {}
set LaLigne {}
lappend LaLigne3L " "
lappend LaLigne " "
lappend LaLigne3L " "
if {$AllOrA=="All"} {
lappend LaLigne " -All- "
} else {
set System [MSP Syn $A System]
set Mut3L [Mut3L $A]
lappend LaLigne "[format " %-5s" $System] "
}
foreach C $LesC {
set T [string totitle [UT $C]]
if {$C=="X"} { set T " * " }
lappend LaLigne3L " $T"
lappend LaLigne " $C"
}
lappend LaSortie [join $LaLigne3L ""]
lappend LaSortie [join $LaLigne ""]
set LaLigne [list " "]
foreach C $LesC {
if {$ConsLocal!=""} {
set MCount 0
set AllA $AllOrA
if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
foreach A $AllA {
foreach L [MSP All ListOf A] {
foreach PosMut [MSP Mut $A $L$C-Pos] {
foreach PosCon [MSP Con $A $ConsLocal] {
if {0 && $A=="A"} { Espionne "$C $A $L $PosMut $PosCon $ConsLocal" }
if {$PosMut==$PosCon} { incr MCount }
}
}
}
}
} else {
set MCount [MSP Mut $AllOrA $C-MCount]
if {$MCount==""} { set MCount 0 }
}
lappend LaLigne [format "%4d" $MCount]
}
lappend LaSortie [join $LaLigne ""]
set LaLigne {}
foreach L $LesL {
set T [string totitle [UT $L]]
set LaLigne [list "$T $L"]
if {$ConsLocal!=""} {
set WCount 0
set AllA $AllOrA
if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
foreach A $AllA {
foreach C $LesC {
foreach PosMut [MSP Mut $A $L$C-Pos] {
foreach PosCon [MSP Con $A $ConsLocal] {
if {$PosMut==$PosCon} { incr WCount }
}
}
}
}
} else {
set WCount [MSP Mut $AllOrA $L-WCount]
}
if {$WCount==""} { set WCount 0 }
lappend LaLigne [format "%4d" $WCount]
foreach C $LesC {
set T " "
if {$ConsLocal!=""} {
set NbCons 0
set AllA $AllOrA
if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
foreach A $AllA {
foreach PosMut [MSP Mut $A $L$C-Pos] {
foreach PosCon [MSP Con $A $ConsLocal] {
if {$PosMut==$PosCon} {
incr NbCons
if { ! [info exists MemoNbConsMut($A)]} { set MemoNbConsMut($A) 0 }
incr MemoNbConsMut($A)
}
}
}
}
if {$NbCons!=0} { set T [format "%4d" $NbCons] }
} else {
if {$L!=$C} {
set WMCount [MSP Mut $AllOrA $L$C-Count]
if {$WMCount!=""} { set T [format "%4d" $WMCount] }
}
}
lappend LaLigne $T
}
lappend LaSortie [join $LaLigne ""]
}
lappend LaSortie ""
set AllA $AllOrA
if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
foreach A $AllA {
set Systeme [MSP Syn $A System]
set SeqLength [MSP Syn $A SeqLength]
if {$SeqLength==""} { continue }
set NbMut [llength [MSP Mut $A ListOfPos]]
set PcMut [format %4.1f [expr (100.*$NbMut)/$SeqLength]]
if {$ConsLocal=="AllLocal"} {
set NbConsTot [llength [MSP Con $A $ConsLocal]]
set PcConsTot [expr (100*$NbConsTot)/$SeqLength]
if {[info exists MemoNbConsMut($A)]} { set NbConsMut $MemoNbConsMut($A) } else { set NbConsMut 0 }
set PcConsMut "-"
if {$NbConsTot>0} { set PcConsMut [format %4.1f [expr (100.*$NbConsMut)/$NbConsTot]] }
lappend LesStat "[format %-5s $Systeme] SeqLength:[format %4d $SeqLength] NbConsTot:[format %3d $NbConsTot] ([format %2d $PcConsTot]%) NbMut:[format %2d $NbMut] ($PcMut%) NbConsMut:$NbConsMut ($PcConsMut%)"
} else {
lappend LesStat "[format %-5s $Systeme] SeqLength:[format %4d $SeqLength] NbMut:$NbMut"
}
}
LConcat LaSortie $LesStat
if {$Action=="GetAsText"} { return [join $LaSortie "\n"] }
return [AfficheListe $LaSortie "" "FromWtoM_${AllOrA}_${Conservation}_${Order}"]
}
proc MSP {{Qui ""} {Quoi ""} {Quid ""}} {
#rR On regroupe ici toutes les infos sur les Syn les Mut, les Con, les Dis
#rR Attention pour avoir la liste des AA il faut faire MSP All ListOf A (et non pas Syn ou Mut)
global MSP
set FichierMemo "[MiSynPatDir]/MSP_Memo.txt"
if {[regexp -nocase "^ReDo_" $Qui]} {
if {[file exists $FichierMemo]} {
file delete $FichierMemo
if {[info exists MSP("EstCharge")]} { unset MSP }
}
regsub -nocase "^ReDo_" $Qui "" Qui
return [MSP $Qui $Quoi $Quid]
}
if {[info exists MSP($Qui,$Quoi,$Quid)]} { return $MSP($Qui,$Quoi,$Quid) }
if {[info exists MSP("EstCharge")]} { return "" }
set MSP("EstCharge") 1
if {[file exists $FichierMemo]} {
array set MSP [ContenuDuFichier $FichierMemo]
return [MSP $Qui $Quoi $Quid]
}
CanalSql [ConnInfoForDatabase MiSynPat]
set LesDis [SqlExec "select pk_disease,sdisease,ldisease,omim from disease" "GetList"]
foreach {PkD SDis LDis Omim} $LesDis {
set MSP(Dis,$PkD,pkd) $PkD
set MSP(Dis,$PkD,sdis) $SDis
set MSP(Dis,$PkD,ldis) $LDis
set MSP(Dis,$PkD,omim) $Omim
lappend MSP(Dis,ListOf,pkd) $PkD
lappend MSP(Syn,ListOf,ldis) $LDis
}
set LesSyn [SqlExec "select pk_synthetase,sName,accession from synthetase" "GetList"]
foreach {PkS SName Accession} $LesSyn {
set System [string toupper $SName]
set A [string index $System 0]
set MSP(Syn,$A,System) $System
set MSP(Syn,$A,pk) $PkS
set MSP(Syn,$A,A) $A
set MSP(Syn,$A,Accession) $Accession
set MSP(Syn,$PkS,A) $A
set MSP(Syn,$PkS,Accession) $Accession
set MSP(Syn,$System,A) $A
set MSP(Syn,$System,System) $System
set MSP(Syn,$System,Accession) $Accession
set MSP(Syn,$Accession,A) $A
set MSP(Syn,$Accession,pk) $PkS
set MSP(Syn,$Accession,System) $System
lappend MSP(Syn,ListOf,A) $A
lappend MSP(Syn,ListOf,pk) $PkS
lappend MSP(Syn,ListOf,System) $System
lappend MSP(Syn,ListOf,Accession) $Accession
}
set MSP(All,ListOf,A) $MSP(Syn,ListOf,A)
lappend MSP(All,ListOf,A) "Q"
set MSP(All,ListOf,A) [lsort -unique $MSP(All,ListOf,A)]
set MSP(Mut,All,ListOfAV1) {}
set MSP(Mut,All,ListOfAV2) {}
set MSP(Mut,All,ListOfW) {}
set MSP(Mut,All,ListOfM) {}
#rR a mis All au lieu de Syn
foreach A $MSP(All,ListOf,A) {
set MSP(Mut,$A,ListOfW) {}
set MSP(Mut,$A,ListOfM) {}
set MSP(Mut,$A,ListOfPos) {}
set MSP(Mut,$A,All-WCount) 0
set MSP(Mut,$A,All-MCount) 0
set MSP(Mut,All,All-WCount) 0
set MSP(Mut,All,All-MCount) 0
foreach B $MSP(All,ListOf,A) {
set MSP(Mut,$A,$B-WCount) 0
set MSP(Mut,$A,$B-MCount) 0
}
}
set LesMut [SqlExec "select * from mutation order by pk_mutation" "GetList"]
foreach {PkM PkB PkD PkS V1 V2 Comment} $LesMut {
set A $MSP(Syn,$PkS,A)
lappend MSP(Mut,ListOf,A) $A
lappend MSP(Mut,$A,ListOfV1) $V1
lappend MSP(Mut,$A,ListOfV2) $V2
lappend MSP(Mut,$A,ListOfCo) $Comment
lappend MSP(Mut,All,ListOfV1) $V1
lappend MSP(Mut,All,ListOfV2) $V2
lappend MSP(Mut,All,ListOfAV1) "$A $V1"
lappend MSP(Mut,All,ListOfAV2) "$A $V2"
lappend MSP(Mut,All,ListOfCo) $Comment
set MSP(Mut,$PkM,pkd) $PkD
foreach V [list $V1 $V2] {
if { ! [info exists DejaVu($V)] && ! [regexp "XXXXXX" $V] && [regexp {^([A-Z])([0-9]+)([A-Z])$} $V Match W Pos M] } {
set DejaVu($V) 1
lappend MSP(Mut,$A,ListOfW) $W
lappend MSP(Mut,$A,ListOfM) $M
lappend MSP(Mut,$A,ListOfPos) $Pos
lappend MSP(Mut,All,ListOfW) $W
lappend MSP(Mut,All,ListOfM) $M
lappend MSP(Mut,All,ListOfPos) $Pos
incr MSP(Mut,$W,All-WCount)
incr MSP(Mut,$M,All-MCount)
incr MSP(Mut,$A,$W-WCount)
incr MSP(Mut,$A,$M-MCount)
incr MSP(Mut,$A,$W$M-Count)
incr MSP(Mut,All,$W-WCount)
incr MSP(Mut,All,$M-MCount)
incr MSP(Mut,All,$W$M-Count)
lappend MSP(Mut,$A,$W$M-Pos) $Pos
}
}
set MSP(Mut,$A,ListOfWunique) [lsort -unique $MSP(Mut,$A,ListOfW)]
set MSP(Mut,$A,ListOfMunique) [lsort -unique $MSP(Mut,$A,ListOfM)]
}
set MSP(Mut,All,ListOfW) [lsort -unique $MSP(Mut,All,ListOfW)]
set MSP(Mut,All,ListOfM) [lsort -unique $MSP(Mut,All,ListOfM)]
set MSP(Mut,ListOf,A) [lsort -unique $MSP(Mut,ListOf,A)]
#rR j'ai mis All au lieu de Mut pour la liste
foreach A $MSP(All,ListOf,A) {
if { ! [info exists MSP(Mut,$A,ListOfW)]} { set MSP(Mut,$A,ListOfW) {} }
if { ! [info exists MSP(Mut,$A,ListOfM)]} { set MSP(Mut,$A,ListOfM) {} }
if { ! [info exists MSP(Mut,$A,ListOfPos)]} { set MSP(Mut,$A,ListOfPos) {} }
set MSP(Mut,$A,ListOfW) [lsort -unique $MSP(Mut,$A,ListOfW)]
set MSP(Mut,$A,ListOfM) [lsort -unique $MSP(Mut,$A,ListOfM)]
set MSP(Mut,$A,ListOfPos) [lsort -unique $MSP(Mut,$A,ListOfPos)]
}
foreach Nom [ListeDesPABs] {
set A [ExtraitInfo $Nom A]
set MSP(Syn,$A,Nom) $Nom
foreach Cons [list IdenGlob ConsGlob SimiGlob AllGlob IdenLocal ConsLocal SimiLocal AllLocal] {
set MSP(Con,$A,$Cons) {}
}
set MSP(Syn,$Nom,A) $A
set MonAccess "${A}mito_Homo.sapi"
set MSP(Syn,$A,MonAccess) $MonAccess
set LesConservations [MSPFroMac $Nom Cons-T80 $MonAccess]
foreach Ligne $LesConservations {
lassign $Ligne coords Coords ftype FType fstart FStart fstop FStop fcolor FColor fscore FSCore fnote FNote
lappend MSP(Con,$A,$FNote) $FStart
}
set MSP(Con,$A,AllGlob) {}
foreach Cons [list IdenGlob ConsGlob SimiGlob] {
LConcat MSP(Con,$A,AllGlob) $MSP(Con,$A,$Cons)
}
set MSP(Con,$A,AllGlob) [lsort -unique -integer $MSP(Con,$A,AllGlob)]
foreach Cons [list IdenGlob ConsGlob SimiGlob AllGlob] {
regsub "Glob" $Cons "Local" Loca
set MSP(Con,$A,$Cons) [lsort -integer $MSP(Con,$A,$Cons)]
if {[info exists EstGlo]} { unset EstGlo ; set EstGlo(bidon) 1 }
foreach Pos $MSP(Con,$A,$Cons) {
set EstGlo($Pos) 1
}
set Seq [MSPFroMac $Nom Sequences $MonAccess]
set MSP(Syn,$A,SeqWithGap) $Seq
regsub -all -nocase {[^a-z]} $Seq "" SeqWithoutGap
set MSP(Syn,$A,SeqWithoutGap) $SeqWithoutGap
set L 0
set G 0
if {0 && $A=="A" && $Cons=="IdenGlob"} {
Espionne $MonAccess
Espionne $Seq
Espionne [string length $Seq]
}
foreach C [split $Seq ""] {
incr G
if {$C!="-" && $C!="."} { incr L ; if {$A=="A" && $Cons=="IdenGlob"} { Espionne "=$C= $L" } }
if {[info exists EstGlo($G)]} { lappend MSP(Con,$A,$Loca) $L }
}
}
set LesPos {}
set SeqLength [string length [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"]]
set MSP(Syn,$A,SeqLength) $SeqLength
foreach i [NombresEntre 1 $SeqLength] {
lappend LesPos $i
}
set MSP(Con,$A,NoLocal) [ListsComplement $LesPos $MSP(Con,$A,AllLocal)]
}
CanalSqlDisconnect
Sauve [array get MSP] dans $FichierMemo
return [MSP $Qui $Quoi $Quid]
}
proc AAType {{Qui ""}} {
global AAType
if {[info exists AAType($Qui)]} { return $AAType($Qui) }
if {[info exists AAType("EstCharge")]} { return "" }
set AAType(aliphatic) [list I L M V]
set AAType(aromatic) [list F Y W]
set AAType(acidic) [list D E Q N]
set AAType(basic) [list H K R]
set AAType(scmall) [list P A G S T]
set AAType(cystein) [list C]
foreach K [lsort [array names AAType]] {
set V $AAType($K)
lappend AAType(Types) $K
foreach A $V {
lappend AAType(ListOfA) $A
set AAType($A) $K
}
}
set Ordonnes {}
set AAType(AlphabeticListOfAA) [lsort $AAType(ListOfA)]
set AAType("EstCharge") 1
return [AAType $Qui]
}
proc SeqCalagePourTous {} {
foreach Nom [ListeDesPABs] {
Espionne [SeqCalage $Nom]
}
}
proc SeqCalage {Nom} {
set Tfa "" ; set FiTfa [GscopeFile $Nom prottfa]
set Hit "" ; set FiHit [GscopeFile $Nom prottfa_besthumanhit]
set Acc "" ; set FiAcc [GscopeFile $Nom prottfa_access]
if {[FileExists $FiTfa]} { set Tfa [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiTfa]]] }
if {[FileExists $FiHit]} { set Hit [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiHit]]] }
if {[FileExists $FiAcc]} { set Acc [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiAcc]]] }
set OkHit [string equal $Tfa $Hit]
set OkAcc [string equal $Tfa $Acc]
set InHit [string first $Tfa $Hit]
set InAcc [string first $Tfa $Acc]
if {$OkHit} { return 1; [FaireLire "$Nom Ok. Les séquences sont pile-poil égales !"] }
set LesParties [list 2 3 4]
foreach Part $LesParties {
set MTfa [expr [string length $Tfa]/$Part]
set Bout [string range $Tfa $MTfa $MTfa+9]
set MHit [string first $Bout $Hit]
set XTfa [string first $Bout $Tfa]
if {$MHit>=0} { break }
}
if {$MHit>=0} {
set NbDecal [expr $MTfa - $MHit]
if {$NbDecal<0} {
set N [expr -$NbDecal]
set Decal [string repeat " " $N]
set NewTfa "$Decal$Tfa"
set NewHit $Hit
} else {
set Decal [string repeat " " $NbDecal]
set NewHit "$Decal$Hit"
set NewTfa $Tfa
}
set X ""
foreach CTfa [split $NewTfa ""] CHit [split $NewHit ""] {
if {$CTfa!=$CHit} {
append X "X"
} else {
append X " "
}
}
return [Affiche "$NewTfa\n$NewHit\n$X" "GrandeLargeur" "$Nom"]
}
return [SeeAby "blast_myself" $Nom]
}
proc MakeBlastDatabaseForEachProttfa {} {
file mkdir "[RepertoireDuGenome]/banques_myself"
NousAllonsAuBoulot "[RepertoireDuGenome]/prottfa"
foreach Nom [ListeDesPABs] {
exec formatdb -p T -i $Nom
foreach P [glob -nocomplain "$Nom.*"] {
Espionne $P
file rename $P "[RepertoireDuGenome]/banques_myself/$P"
}
}
OnRevientDuBoulot
}
proc CompareLesSequencesPourMisynpat {} {
set Dir "[RepertoireDuGenome]/blastp_myself"
file mkdir $Dir
NousAllonsAuBoulot $Dir
foreach Nom [ListeDesPABs] {
set Tfa "" ; set FiTfa [GscopeFile $Nom prottfa]
set Hit "" ; set FiHit [GscopeFile $Nom prottfa_besthumanhit]
set Acc "" ; set FiAcc [GscopeFile $Nom prottfa_access]
if {[FileExists $FiTfa]} { set Tfa [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiTfa]]] } else { FaireLire "$Nom pas tfa" }
if {[FileExists $FiHit]} { set Hit [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiHit]]] } else { FaireLire "$Nom pas hit" }
if {[FileExists $FiAcc]} { set Acc [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiAcc]]] } else { FaireLire "$Nom pas acc" }
set OkHit [string equal $Tfa $Hit]
set OkAcc [string equal $Tfa $Acc]
set InHit [string first $Tfa $Hit]
set InAcc [string first $Tfa $Acc]
if {"$OkHit $OkAcc $InHit $InAcc"=="1 1 0 0"} { continue }
Espionne "$Nom $OkHit $OkAcc $InHit $InAcc [string length $Tfa] [string length $Hit] [string length $Acc]"
if { [FileExists $FiHit] && ! $OkHit } {
Espionne "blastall -p blastp -i $FiHit -d [RepertoireDuGenome]/banques_myself/$Nom -F F -o $Nom"
exec blastall -p blastp -i $FiHit -d [RepertoireDuGenome]/banques_myself/$Nom -o $Nom
}
if { 0 && [FileExists $FiAcc] && ! $OkAcc } {
Espionne "blastall -p blastp -i $FiAcc -d [RepertoireDuGenome]/banques_myself/$Nom -o $Nom"
exec blastall -p blastp -i $FiAcc -d "[RepertoireDuGenome]/banques_myself/$Nom"
}
}
OnRevientDuBoulot
}
proc InformeBestHumanHitPourTous {} {
FaireLire "Attention ce n'est normalement pas à refaire ..."
file mkdir "[RepertoireDuGenome]/prottfa_besthumanhit"
file mkdir "[RepertoireDuGenome]/protembl_besthumanhit"
set LaSortie {}
foreach Nom [ListeDesPABs] {
set BestHumanHit [BestHumanHit $Nom]
Espionne "$Nom $BestHumanHit"
InformeSansDemander $Nom "=BestHumanHit20170113: $BestHumanHit"
set EMBL [QGQ UniprotData $BestHumanHit]
set FicTfa [Sauve [SequenceFormatTFA $EMBL] dans [GscopeFile $Nom "prottfa_besthumanhit"]]
set FicEmbl [Sauve $EMBL dans [GscopeFile $Nom "protembl_besthumanhit"]]
lappend LaSortie $FicEmbl
}
return $LaSortie
}
proc BestHumanHit {Nom} {
lappend LesVoulus "SY[NomDeMSP $Nom A]M_HUMAN"
lappend LesVoulus "SY[NomDeMSP $Nom A]_HUMAN"
foreach Voulu $LesVoulus {
foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "blastp"]] {
if { ! [regexp {^>([^ ]+) } $Ligne Match BAI]} { continue }
set Access [lindex [split $BAI "|"] end]
if {$Access=="$Voulu"} { return $Access }
}
}
set LesPossibles {}
set Max 55
foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "blastp"]] {
if {[incr Max -1]==0} { break }
if { ! [regexp {>([^ ]+) } $Ligne Match BAI]} { continue }
set Access [lindex [split $BAI "|"] end]
if {[regexp "_HUMAN$" $Access]} { return $Access }
lappend LesPossibles $Access
}
return [ChoixParmi $LesPossibles]
}
proc NomDeMSP {{Qui ""} {Quoi ""}} {
global NomDeMSP
if {$Quoi==""} { set Quoi "Nom" }
set Qui [string touppe $Qui]
set Quoi [string touppe $Quoi]
regsub -all "_" $Qui " " Qui
if {[info exists NomDeMSP($Qui,$Quoi)]} { return $NomDeMSP($Qui,$Quoi) }
if {[info exists NomDeMSP("EstCharge")]} {
if {[info exists NomDeMSP($Qui,NOM)]} {
set Nom $NomDeMSP($Qui,NOM)
if {[info exists NomDeMSP($Nom,$Quoi)]} { return $NomDeMSP($Nom,$Quoi) }
}
return ""
}
set NomDeMSP("EstCharge") 1
set NomDeMSP(LISTOF,KEY) [list A AAA System Definition Nom]
foreach Nom [ListeDesPABs] {
set A [ExtraitInfo $Nom A:]
set AAA [ExtraitInfo $Nom AAA:]
set SYSTEM [ExtraitInfo $Nom System:]
set DEFINITION [ExtraitInfo $Nom Definition:]
set NOM $Nom
foreach K $NomDeMSP(LISTOF,KEY) {
set K [string toupper $K]
set NomDeMSP($Nom,$K) [set $K]
set NomDeMSP([string toupper [set $K]],NOM) $Nom
lappend NomMSP(LISTOF,$K) [set $K]
}
}
return [NomDeMSP $Qui $Quoi]
}
proc InformeMSP {} {
CanalSql [ConnInfoForDatabase MiSynPat]
set LaSortie {}
foreach Nom [ListeDesPABs] {
set Entete [EnteteDuFichierTFA [GscopeFile $Nom prottfa]]
scan $Entete "%s %s %s %s %s %s" N Systeme A D1 D2 Access
InformeSansDemander $Nom "=System: $Systeme"
InformeSansDemander $Nom "=A: $A"
InformeSansDemander $Nom "=AAA: [string totitle [UT $A]]"
InformeSansDemander $Nom "=Definition: $D1 $D2"
InformeSansDemander $Nom "=Access: $Access"
set LesLignesEMBL [LaSequenceDesBanques $Access]
if {$LesLignesEMBL!={}} {
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceNarcisse
InformeSansDemander $Nom "=Narcisse_ID: $ID"
InformeSansDemander $Nom "=Narcisse_AC: $AC"
InformeSansDemander $Nom "=Narcisse_DE: $DE"
InformeSansDemander $Nom "=Narcisse_GN: $GN"
set EnteteNarcisse ">$Nom $Access $A $D1 $D2 $Systeme"
lappend LaSortie [Sauve [SequenceFormatTFA $SequenceNarcisse $EnteteNarcisse protbrut] dans [GscopeFile $Nom prottfa_access]]
}
}
return $LaSortie
}
proc MSPFroMac args {
JeMeSignale
if {[PourWscope]} { return [FromMacsim {*}$args] }
set Commande "ret FromMacsim [join $args { }]"
set Res [QuestionDeScience MSP $Commande]
return $Res
}
proc FroMac args {
if {[PourWscope]} { return [FromMacsim {*}$args] }
set Commande "ret FromMacsim [join $args { }]"
set Res [QuestionDeScience Zero $Commande]
return $Res
}
proc CreateProjectMSP {} {
FaireLire "Attention tout est déjà fait. A manipuler avec précautions"
CanalSql [ConnInfoForDatabase MiSynPat]
set XmlDir "[MiSynPatDir]/data/alignments"
foreach XmlFic [lsort [glob -nocomplain "$XmlDir/*_WithModules.xml"]] {
Espionne $XmlFic
exec ln -sf $XmlFic [RepertoireDuGenome]/macsimXml_Ori/MSP
set LesNames [FroMac $XmlFic ListOfNames]
set Moi ""
foreach Name $LesNames {
if {[regexp {^([A-Z])mito_Homo.sapi$} $Name Access A]} { set Moi $Name ; break }
}
if {$Moi==""} { FaireLire "Je ne trouve pas $Access"; continue }
set SeqGap [FroMac $XmlFic Sequences $Access]
regsub -all {\.} $SeqGap "" Seq
set R [SqlExec "select sName, lName, accession, class from synthetase where sname like '$A%'" "GetList"]
lassign $R Systeme Definition Access Class
set Entete "$Systeme $A $Definition $Access"
set TFA [SequenceFormatTFA $Seq $Entete "protbrut"]
Espionne $TFA
# Sauve $TFA dans "/genomics/link/MSP/DeMisynpat/$Systeme.tfa"
}
}
proc TestMSP {} {
set YaCons 0
set LesStart {}
foreach Ligne [LesLignesDuFichier "[HomeRipp]/msp/data/alignments/dcethal1.txt"] {
if {$YaCons && [regexp {<fstart>([0-9]+)</fstart>} $Ligne Match Start]} {
lappend LesStart $Start
set YaCons 0
continue
}
if {[regexp {<ftype>Cons\-T80</ftype>} $Ligne]} { set YaCons 1 ; continue }
}
set LesStart [lsort -integer $LesStart]
Espionne $LesStart
exit
}
proc MiSynPatMajDisease {{DoIt ""}} {
set Fichier "[MiSynPatDir]/disease20151104.csv"
set DoIt [string equal -nocase $DoIt "DoIt"]
CanalSqlMiSynPat
set LesPkModifies {}
foreach Ligne [LesLignesDuFichier $Fichier] {
lassign [split $Ligne ";"] pk sd ld om or
regsub -all "#" $om " " om
regsub -all { +} $om " " om
set om [string trim $om]
if { ! [regexp {^[0-9]+$} $pk] } { continue }
set LesLus [SqlExec "select * from disease where pk_disease=$pk" "GetList"]
lassign $LesLus pkLu sdLu skLu omLu orLu
if {$sd!=$sdLu} {
Espionne $Ligne
Espionne $LesLus
set Sql "update disease set sdisease='$sd' where pk_disease=$pk"
Espionne $Sql
if {$DoIt} { SqlExec $Sql }
lappend LesPkModifies $pk
}
if {$om!=$omLu} {
Espionne $Ligne
Espionne $LesLus
set Sql "update disease set omim='$om' where pk_disease=$pk"
Espionne $Sql
if {$DoIt} { SqlExec $Sql }
lappend LesPkModifies $pk
}
}
CanalSqlDisconnect
if { ! $DoIt } {
Espionne "*****************************************************************"
Espionne "* Attention run 'MiSynPatMajDisease DoIt' if you want to update *"
Espionne "*****************************************************************"
return "I_did_nothing_for_the_moment"
}
return $LesPkModifies
}
proc SortByStart {A B} {
scan $A "%s %d" BidonA StartA
scan $B "%s %d" BidonB StartB
if {$StartA<$StartB} { return -1 }
if {$StartA>$StartB} { return 1 }
return 0
}
proc MiSynPatDir {} {
return "[HomeRipp]/wwwLinux/MiSynPat"
}
#rR pour les StructuralModules :
#rR 1/ Marie met à jour le fichier Excel StructuralModules.xlsx
#rR 2/ je le sauve en .csv
#rR 3/ MiSynPatStructuralModulesAsFeatures crée les .feat
#rR 4/ MiSynPatStructuralModulesForDatabase les met dans la database
#rR 5/ MiSynPatAddStructuralModulesToMacsims les met dans les macsims
proc MiSynPatAddStructuralModulesToMacsims {{Force ""} {Lequel ""}} {
set Force [string equal -nocase Force $Force]
set LesNouveaux {}
foreach FeatFile [lsort [glob -nocomplain "[MiSynPatDir]/data/StructuralModulesFeatures/$Lequel*.feat"]] {
if { ! [regexp {/[A-Z].feat$} $FeatFile] } { continue }
set Queue [file tail $FeatFile]
Espionne $Queue
set A [file rootname $Queue]
set MacsimsIn "[MiSynPatDir]/data/alignments/${A}_WithModules.xml"
set MacsimsOut "[MiSynPatDir]/data/alignments/${A}_WithModules_new.xml"
if {[FileAbsent $MacsimsIn] } { Warne "$MacsimsIn does not exist" ; continue }
if {[FileExists $MacsimsOut] && ! $Force} { Warne "$MacsimsOut already exists" ; continue }
set Reponse [exec ordali $MacsimsIn -exe AddModules $FeatFile] ;#rR on y rajoute _WithModules
set Recu [lindex [split $Reponse " "] end]
Warne "Ordali created $Recu"
lappend LesNouveaux $Recu
}
return $LesNouveaux
}
proc StructuralModuleColor {Qui} {
global SMC
set Qui [string tolower $Qui]
if {[info exists SMC($Qui)]} { return $SMC($Qui) }
if {[info exists SMC("EstCharge")]} { return "grey" }
set SMC("EstCharge") 1
set CM "
brown;C-terminal extension domain
blue;Anticodon Binding domain
green;alpha-helical domain
green;Bacterial-type C-terminal extension
green;TGS domain
green;tRNA edge-binding domain
green;WHEP domain
lightgreen;second additional domain
magenta;Putative MTS
orange;Insertion domain
red;Catalytic domain
cyan;Helix of dimerization
grey;HIGH
grey;KMSKS
grey;motif_1
grey;motif_2
grey;motif_3
"
regsub -all {[\;\n]+} [string trim $CM "\n;"] ";" CM
foreach {C D} [split $CM ";"] {
set SMC([string tolower [string trim $D]]) $C
}
return [StructuralModuleColor $Qui]
}
proc MspModule {{Qui ""} {Quoi ""} {Quid ""}} {
return [MiSynPatStructuralModulesForDatabase $Qui $Quoi $Quid "GetIt"]
}
proc MiSynPatStructuralModulesForDatabase {{Qui ""} {Quoi ""} {Quid ""} {GetWhat ""}} {
#rR GetWhat = GetIt pour avoir les infos
#rR GetWhat = ShowIt pour voir les commandes sql de mise à jour de la table synthtase.features de MiSynpat.sql
#rR GetWhat = DoIt pour mettre à jour la table synthtase.features de MiSynpat.sql
#rR Attention il faut avoir fait les .feat avec MiSynPatStructuralModulesAsFeatures
regsub -all " " $Quoi "_" Quoi
regsub -all " " $Quid "_" Quid
if {$GetWhat==""} { set GetWhat "GetIt" }
set GetIt [string equal -nocase $GetWhat "GetIt"]
set ShowIt [string equal -nocase $GetWhat "ShowIt"]
set DoIt [string equal -nocase $GetWhat "DoIt"]
package require sqlite3
set File "[MiSynPatDir]/misynpat.sql"
set db "root"
sqlite3 $db $File
set NFs [$db eval {select sName,features from synthetase order by sName}]
set LesTodo {}
set LesDone {}
foreach {N Features} $NFs {
set A [string index $N 0]
set LesFeatures [split $Features ","]
set SeqLen [string trim [lindex $LesFeatures 0] "'"]
set LesFeatures [lrange $LesFeatures 1 end]
set LesFeatures [lsort -command SortByStart $LesFeatures]
#rR ici on remplit Module pour le GetIt ................ en partant de sql
foreach Feature $LesFeatures {
regsub -all "'" $Feature "" Feature
set LesMots [split $Feature " "]
lassign $LesMots Acc Deb Fin Color Name
set A [string index $Acc 0]
lappend Module($A,Modules,) "$Deb $Fin $Color $Name"
lappend Module(ListOf,A,) $A
lappend Module(ListOf,Name,) $Name
}
#rR ici on prepare les new pour la mise à jour ......... en partant des .feat
if {$DoIt || $ShowIt} {
set LesNews {}
foreach Ligne [LesLignesDuFichier "[MiSynPatDir]/data/StructuralModulesFeatures/$A.feat"] {
if {[regexp "^FEATURE" $Ligne]} { continue }
set LesMots [split $Ligne ";"]
lassign $LesMots Acc Loc Deb Fin Color Score Comment
regsub -all " " $Comment "_" Comment
set NewFeat "$Acc $Deb $Fin $Color $Comment"
lappend LesNews $NewFeat
}
set New "'$SeqLen','[join $LesNews ',']'"
if {$ShowIt} {
lappend LesTodo "$db eval {update synthetase set features=$New where sName=$N}"
}
if {$DoIt} {
$db eval {update synthetase set features=$New where sName=$N}
lappend LesDone $Acc
}
}
}
if { $ShowIt } { return $LesTodo }
if { $DoIt } { return $LesDone }
#GetIt
set Module(ListOf,A,) [lsort -unique $Module(ListOf,A,)]
set Module(ListOf,Name,) [lsort -unique $Module(ListOf,Name,)]
if {[info exists Module($Qui,$Quoi,$Quid)] } { return $Module($Qui,$Quoi,$Quid) }
if {[info exists Module($Qui,Modules,)] } {
foreach Mod $Module($Qui,Modules,) {
lassign $Mod Deb Fin Color Name
set DF "$Deb-$Fin"
regsub -all " " $Name "_" Name
set Module($Qui,$Name,Name) $Name
set Module($Qui,$Name,DF) $DF
set Module($Qui,$Name,Deb) $Deb
set Module($Qui,$Name,Fin) $Fin
set Module($Qui,$Name,Color) $Color
lappend Module($Qui,ListOf,Name) $Name
lappend Module($Qui,ListOf,DF) $DF
lappend Module($Qui,ListOf,Deb) $Deb
lappend Module($Qui,ListOf,Fin) $Fin
lappend Module($Qui,ListOf,Color) $Color
foreach K [list DF Deb Fin Name] {
set Module($Qui,[set $K],Name) $Name
set Module($Qui,[set $K],DF) $DF
set Module($Qui,[set $K],Deb) $Deb
set Module($Qui,[set $K],Fin) $Fin
set Module($Qui,[set $K],Color) $Color
}
}
if {[info exists Module($Qui,$Quoi,$Quid)]} { return $Module($Qui,$Quoi,$Quid) }
return ""
}
return ""
}
proc MiSynPatStructuralModulesAsFeatures {} {
#rR On crée les fichiers features qui seront intégrés dans les macsims et dans la base de données
foreach A [MiSynPatStructuralModules ListOf A] {
set LesSM {}
lappend LesSM "FEATURE MODULE PROPAGATE all"
foreach L [MiSynPatStructuralModules $A Limits] M [MiSynPatStructuralModules $A Domains] {
lassign [split $L "-"] D F
regsub -all "_" $M " " M
set Color [StructuralModuleColor $M]
Espionne "$L $D $F $M"
lappend LesSM "${A}mito_Homo.sapi;local;$D;$F;$Color;0.0;$M"
}
if {[llength $LesSM]==1} { continue }
set a [string tolower $A]
set Fichier "${A}.feat"
lappend LesNouveaux [SauveLesLignes $LesSM dans $Fichier]
}
return $LesNouveaux
}
proc MiSynPatStructuralModules {{Qui ""} {Quoi ""}} {
#rR On lit le fichier Excel de Marie
#rR Attention je fais quelques petites tricheries pour corriger les incohérences
#rR Attention on remplace tous les blancs par des _
global SM
if {$Qui=="" && $Quoi==""} {
set LeHelp {}
set Com "gscope puts"
if {[PourWscope]} { set Com "qds MSP" }
lappend LeHelp "Usage with $Com"
lappend LeHelp " $Com puts MiSynPatStructuralModules ListOf A"
lappend LeHelp " $Com MiSynPatStructuralModules ListOf AAA"
lappend LeHelp "And for each A ou 3 letters amino acid"
lappend LeHelp " $Com MiSynPatStructuralModules Asp class"
lappend LeHelp " $Com MiSynPatStructuralModules Asp Domains"
lappend LeHelp "and for each domain of Asp"
lappend LeHelp " $Com MiSynPatStructuralModules Asp Catalytic_domain"
lappend LeHelp "or"
lappend LeHelp " $Com MiSynPatStructuralModules Asp Limits"
lappend LeHelp " $Com MiSynPatStructuralModules Asp 208-608"
return [join $LeHelp "\n"]
}
if {[info exists SM($Qui,$Quoi)]} { return $SM($Qui,$Quoi) }
if {[info exists SM($Qui,I)]} {
set I $SM($Qui,I)
if {[info exists SM($I,$Quoi)]} { return $SM($I,$Quoi) }
return ""
}
if {[info exists SM("EstCharge")]} { return "" }
set SM("EstCharge") 1
set LesDomainesConnus [list HIGH KMSKS motif_1 motif_2 motif_3 Putative_MTS Anticodon_Binding_domain Catalytic_domain Insertion_domain helix_of_dimerization]
set Fichier "[MiSynPatDir]/data/StructuralModulesFeatures/StructuralModules.csv"
LoadTxlWithRowsOfCells $Fichier SM -1 ";"
foreach I $SM(ListAllPlease,) {
set A $SM($I,1_letter_code)
set AAA $SM($I,3_letters_code)
lappend SM(ListOf,A) $A
lappend SM(ListOf,AAA) $AAA
set SM($A,I) $I
set SM($AAA,I) $I
set SM($I,A) $A
set SM($I,AAA) $AAA
if {$SM($I,HIGH)==""} {
set SM($I,class) "I"
} else {
set SM($I,class) "II"
}
set SM($I,Limits) {} ;#rR attention dans un deuxième temps on changera l'ordre en gardant le parallele Limits Domains
set SM($I,Domains) {}
if {[regexp "/" $SM($I,Others)]} { set SM($I,Others) "" }
if {$SM($I,Others)!=""} {
regsub -nocase {SAD *= *ThrRS and AlaRS} $SM($I,Others) "" SM($I,Others)
set SM($I,Others) [string trim $SM($I,Others)]
set Others $SM($I,Others)
set Names $SM($I,name_of_Others)
if {[regexp " and " $Others]} {
regsub " and " $Others "@" Others
regsub "omain and " $Names "omain@" Names
set LesLimites [split $Others "@"]
set LesDomaines [split $Names "@"]
} else {
set LesLimites [list $Others]
set LesDomaines [list $Names]
}
set LesD {}
foreach D $LesDomaines {
regsub -all " " $D "_" D
lappend LesD $D
}
set LesDomaines $LesD
set SM($I,Limits) $LesLimites
set SM($I,Domains) $LesDomaines
}
foreach Dom $LesDomainesConnus {
if {[regexp "/" $SM($I,$Dom)]} { set SM($I,$Dom) "" }
if {$SM($I,$Dom)==""} { continue }
lappend SM($I,Limits) $SM($I,$Dom)
lappend SM($I,Domains) $Dom
}
}
foreach I $SM(ListAllPlease,) {
foreach L $SM($I,Limits) D $SM($I,Domains) {
set SM($I,$L) $D
}
set SM($I,Limits) [lsort -command SortLimits $SM($I,Limits)]
set OrderedDomains {}
set OrderedLimits {}
set LesPetits {}
foreach L $SM($I,Limits) {
#Espionne "$L $SM($I,$L)"
lassign [split $L "-"] D F
if {$F-$D<12} { lappend LesPetits $L ; continue }
lappend OrderedDomains $SM($I,$L)
lappend OrderedLimits $L
}
foreach L $LesPetits {
lappend OrderedDomains $SM($I,$L)
lappend OrderedLimits $L
}
#Espionne $OrderedDomains
#Espionne $OrderedLimits
set SM($I,Domains) $OrderedDomains
set SM($I,Limits) $OrderedLimits
}
set SM(Queue,) $SM(Queue)
return [MiSynPatStructuralModules $Qui $Quoi]
}
proc SortLimits {A B} {
scan $A "%d" StartA
scan $B "%d" StartB
if {$StartA<$StartB} { return -1 }
if {$StartA>$StartB} { return 1 }
return 0
}
proc SchemaPFAM {} {
set LName [list "AARS2" "CARS2" "DARS2" "EARS2" "FARS2" "GARS " "HARS2" "IARS2" "KARS " "LARS2" "MARS2" "NARS2" "PARS2" "RARS2" "SARS2" "TARS2" "VARS2" "WARS2" "YARS2"]
foreach Name $LName {
FeaturesdesMacsims $Name
}
}
proc FeaturesdesMacsims { Name } {
global LNOrdali LSOrdali TabSF ListeTypeDeFeatures
unset -nocomplain LNOrdali LSOrdali TabSF ListeTypesDeFeatures Sequences TDesAccess
set Fichier "[MiSynPatDir]/misynpat.sql"
set db "root"
sqlite3 $db $Fichier
set Lfeatin [list]
set system [string index $Name 0]
try {
set fileMacsim "[MiSynPatDir]/data/alignments/${system}_maj.xml"
} on error {result options} {
Espionne -options $options $result
continue
}
DecortiqueUnXml2 $fileMacsim
InitSequences
InitInfoSeqs
AssignSeqToGroup
DonneTabFeature TabSF
::global {*}[info globals "TD*"]
update
set Lsqn [list] ; set Lseq [list] ; set Lacc [list]
foreach n $LNOrdali s $LSOrdali {
if {$n eq ""} {continue}
lappend Lsqn $n
lappend Lacc [set TDesAccess($n)]
lappend Lseq $s
}
regsub -all {\.} $Lseq {\-} Lseq
set idmito [lsearch -glob -inline $Lsqn "${system}mi*_Homo.sapi"]
set indexseqmito [lsearch -glob $Lsqn "$idmito"]
set seqmitoG [lindex $Lseq $indexseqmito]
set accmito [lindex $Lacc $indexseqmito]
regsub -all {\-} $seqmitoG {} seqmitoL
set lenght [string length $seqmitoL]
lappend Lfeatin "'$lenght'"
$db eval {update synthetase set accession=$accmito where sName=$Name}
foreach key [array names TabSF "${system}mi*_Homo.sapi,*"] {
lassign [split $key ,] nom feat
Espionne $feat
if {$feat eq "MODULE"} {
foreach ft $TabSF($key) {
DecortiqueUneFeature $ft start stop col score note csys
lappend Lfeatin "'$nom $start $stop $col $note'"
}
}
}
set featin [join $Lfeatin ","]
Espionne $featin
#$db eval {update synthetase set seq=$featin where sName=$Name}
}
proc FeaturesdunMacsims {} {
global LNOrdali LSOrdali TabSF ListeTypeDeFeatures
#set Names [$db eval {select sName from synthetase}]
set Name "SARS2"
# recupere les données MACSIMS
set system [string index $Name 0]
set fileMacsim "[MiSynPatDir]/data/alignments/${system}_maj.xml"
Espionne "$Name"
Espionne "$system"
Espionne "$fileMacsim"
DecortiqueUnXml2 $fileMacsim
InitSequences
InitInfoSeqs
AssignSeqToGroup
DonneTabFeature TabSF
global {*}[info globals "TD*"]
foreach key [array names TabSF "${system}mi*_Homo.sapi,*"] {
lassign [split $key ,] nom feat
Espionne $feat
if {$feat eq "PFAM-A"} {
foreach ft $TabSF($key) {
DecortiqueUneFeature $ft start stop col score note csys
Espionne "$nom : $start $stop $col $note,"
}
}
}
}
proc SequencesDesVeryLast {} {
global LNOrdali LSOrdali TabSF ListeTypeDeFeatures
set Fichier "[MiSynPatDir]/misynpat.sql"
set db "root"
sqlite3 $db $Fichier
#set Names [$db eval {select sName from synthetase}]
set Names [list "GARS" "KARS"]
foreach Name $Names {
# recupere les données MACSIMS
set system [string index $Name 0]
set fileMacsim "[HomeRipp]/wwwLinux/misynpat/data/alignments/${system}_maj.xml"
Espionne "$Name"
Espionne "$system"
Espionne "$fileMacsim"
DecortiqueUnXml2 $fileMacsim
InitSequences
InitInfoSeqs
AssignSeqToGroup
DonneTabFeature TabSF
global {*}[info globals "TD*"]
set Lsqn [list] ; set Lseq [list] ; set Lacc [list]
foreach n $LNOrdali s $LSOrdali {
if {$n eq ""} {continue}
lappend Lsqn $n
lappend Lacc [set TDesAccess($n)]
lappend Lseq $s
}
set idmito [Lsearch -glob -inline $Lsqn "${system}mi*_Homo.sapi"]
set indexseqmito [Lsearch -glob $Lsqn "$idmito"]
set accmito [lindex $Lacc $indexseqmito]
set seqmitoG [lindex $Lseq $indexseqmito]
regsub -all {\.} $seqmitoG {} seqmitoL
}
}
proc InitDBMisynpat {} {
package require sqlite3
LesDefauts Mode batch
set table "
- synthetase {
. pk_synthetase P
. sName V5
. lName V40
. accession V16
. dateMod V10
. class V1
. seq T
}
- biblio {
. pk_biblio P
. pmid V16
. accepted I -1 : pas vu ; 0 refuse ; 1 accepte
. abstract T
. sJournal V64
. auteurs T
. pages V10
. datem V10
. datey V10
. titre T
. volume V4
}
- mutation {
. pk_mutation P
. pk_biblio I
. pk_disease I
. pk_synthetase I
. variant1 V16
. variant2 V16
}
- disease {
. pk_disease P
. sdisease V16
. ldisease T
. omim V10
. organs T
}
- ln_biblio_synthetase {
. pk_biblio I
. pk_synthetase I
}
- ln_disease_synthetase {
. pk_disease I
. pk_synthetase I
}
- structure {
. pk_structure P
. pk_synthetase I
. id V4 NULL if model from PHYRES2
. seqname V32
. pcid R identity percent with human mito
}
"
set FichierSql "./misynpat.sql"
if {[file exists $FichierSql]} { file delete $FichierSql }
set db [FabriqueDeTables $table "" misynpat.sql]
set LsName [list AARS2 CARS2 DARS2 EARS2 FARS2 GARS HARS2 IARS2 KARS LARS2 MARS2 NARS2 PARS2 RARS2 SARS2 TARS2 VARS2 WARS2 YARS2]
set LlName [list "Alanyl-tRNA synthetase" "Cysteinyl-tRNA synthetase" "Aspartyl-tRNA synthetase" "Glutamyl-tRNA synthetase" "Phenylalanyl-tRNA synthetase" "Glycyl-tRNA synthetase" "Histidyl-tRNA synthetase" "Isoleucyl-tRNA synthetase" "Lysyl-tRNA synthetase" "Leucyl-tRNA synthetase" "Methionyl-tRNA synthetase" "Asparaginyl-tRNA synthetase" "Prolyl-tRNA synthetase" "Arginyl-tRNA synthetase" "Seryl-tRNA synthetase" "Threonyl-tRNA synthetase" "Valyl-tRNA synthetase" "Tryptophanyl-tRNA synthetase" "Tyrosyl-tRNA synthetase"]
set LpdbName [list AARS2 CARS2 "4AH6" EARS2 "3CMQ" GARS HARS2 IARS2 KARS LARS2 MARS2 NARS2 PARS2 RARS2 SARS2 TARS2 VARS2 WARS2 "2PID"]
set Lclass [list "2" "1" "2" "1" "2" "2" "2" "1" "2" "1" "1" "2" "2" "1" "2" "2" "1" "1" "1"]
set Laccess [list ]
set Lsdisease [list "LBSL" "PCH6" "MLASA" "HUPRA" "PS" "ARSAL" "" "" "" "" "" "" "" "" "" ]
set Lldisease [list "Leukoencephalopathy with Brain stem and Spinal cord involvement and Lactate elevation" "PontoCerebellar Hypoplasia type 6" "Myopathy, Lactic Acidosis and Sideroblastic Anemia" "HyperUricemia, Pulmonary hypertension and Renal failure in infancy and Alkalosis" "Perrault Syndrome" "Autosomal Recessive Spastic Ataxia with Leukoencephalopathy" "Early-onset Leukoencephalopathy with Thalamus and Brain stem involvment and high Lactate" "Infantil mitochondrial Alpers Encephalopathy" "Perrault Syndrome, with premature ovarian failure and hearing loss" "Early onset mt encephalopathy: microcephaly and epilepsy associated with isolated deficiency of the mt respiratory chain complex I" "Early onset mt encephalopathy: axial hypotonia and severe psychomotor delay associated with multiple mt respiratory chain defects" "Cataracts, growth hormone deficiency with short stature, partial sensorineural deafness, and peripheral neuropathy or Leigh Syndrome" "MERRF-like syndrome with severe myoclonic epilepsy, progressive spastic tetraparesis, impairment of vision, hearing and cognitive decline" "Leigh Syndrome with congenital auditory neuropathy and nonsyndromic hearing loss" "Infantil Mitochondrial Cardiomyopathy"]
$db eval {begin transaction}
set ::VariablesAuDepart [info globals]
set Defauts(Mode) batch
foreach s $LsName l $LlName c $Lclass {
#set sys [string index $s 0]
#set file [file join $MisyDir alignements ${sys}_VeryLastFinal.xml]
#LoadingAlignment $file
#"set seq [set ::Sequences($a)]
#set ssg [string map {"." "" - ""} $seq]
$db eval {insert into synthetase values (NULL,$s,$l,NULL,"20150101",$c,$ssg)}
}
foreach sd $Lsdisease ld $Lldisease {
$db eval {insert into disease values (NULL,$sd,$ld,NULL,NULL)}
}
$db eval {commit}
return
}
proc PubmedField {Pmid Field} {
array set TInfo [eFetchREST pubmed $Pmid]
parray TInfo
if { ! [info exists TInfo($Pmid,$Field)]} { return "" }
return $TInfo($Pmid,$Field)
}
proc SurveillancePubmed {{GetWhat ""} {AllFields ""}} {
package require sqlite3
package require tdom
regsub -nocase GetNews $GetWhat "GetNew" GetWhat
regsub -nocase GetResults $GetWhat "GetResult" GetWhat
if {$AllFields==""} { set AllFields "AllFields" }
set AllFields [string equal -nocase $AllFields "AllFields"]
set WebServer "lbgi.fr"
if {[info exists ::env] && [info exists ::env(HOST)]} {
set Host [set ::env(HOST)]
if {$Host=="bob"} {
set WebServer "misynpat.org"
} else {
set WebServer "lbgi.fr"
}
}
set Fichier "[MiSynPatDir]/misynpat.sql"
set db "root"
if {$AllFields} {
set FieldSystemes ""
set FieldNecessaires ""
} else {
set FieldSystemes "\[TIAB\]"
set FieldNecessaires "\[TIAB\]"
}
set DateRange {"2007"[Date - Publication] : "3000"[Date - Publication]}
set LesSystemes [list aars2 cars2 dars2 ears2 fars2 gars gars2 hars2 iars2 kars kars2 lars2 mars2 nars2 pars2 rars2 sars2 tars2 vars2 wars2 yars2]
lappend LesSystemes mtARS
set LaQuerySystemes {}
foreach Term $LesSystemes {
if {($Term=="gars" || $Term=="kars")} {
lappend LaQuerySystemes "\"$Term\"\[TIAB\]"
} else {
lappend LaQuerySystemes "\"$Term\"$FieldSystemes"
}
}
set QuerySystemes [join $LaQuerySystemes " OR "]
set LesMotsNecessaires [list mutation mutations patient patients subject subjects disease diseases disorder disorders lbsl leukoencephalopathy]
foreach Term $LesMotsNecessaires {
lappend LaQueryMotsNecessaires "\"$Term\"$FieldNecessaires"
}
set QueryMotsNecessaires [join $LaQueryMotsNecessaires " OR "]
set Langue {"English"[Language]}
set QueryMitoSynMut "mitochondrial\[TIAB\] and aminoacyl-tRNA\[TIAB\] and synthetase\[TIAB\] and mutation*\[TIAB\]"
set Query "($DateRange) AND (($QueryMitoSynMut) OR (($QuerySystemes) AND ($QueryMotsNecessaires) NOT Kainate\[TIAB\] NOT Groningen\[TIAB\])) AND $Langue"
if {$GetWhat=="GetQuery"} { return $Query }
set Query [list "[string map {"\"" "\\\""} $Query]"]
set Lsearch [eSearchREST pubmed $Query]
puts "\nLsearch $Lsearch" ; #rR repris de /home/moumou/mis.tcl 20210408
set Lsearch [eSearchProcessXML $Lsearch]
set LesKarsGarsMalTopes {}
foreach Ligne [LesLignesDuFichier "/home/ripp/msp/KarsTurkey.txt"] {
scan $Ligne "%d" Pmid
lappend LesKarsGarsMalTopes $Pmid
}
set Lsearch [ListsComplement $Lsearch $LesKarsGarsMalTopes]
if {$GetWhat=="GetResult"} { return $Lsearch }
sqlite3 $db $Fichier
set Lold [$db eval {select pmid from biblio}]
set Lnew [ListsComplement $Lsearch $Lold]
puts "Lnew \n$Lnew"
if {$GetWhat=="GetNew"} {
return $Lnew
}
foreach Pmid $Lsearch {
puts $Pmid
set Title [InfoPubmed $Lsearch $Pmid Title]
set Abstract [InfoPubmed $Lsearch $Pmid Abstract]
set PubYear [InfoPubmed $Lsearch $Pmid PubYear]
set PubMonth [InfoPubmed $Lsearch $Pmid PubMonth]
set LesHitSysteme {}
foreach Term $LesSystemes {
if {[regexp -nocase "\[^a-z\]$Term\[^a-z\]" " $Title "]} { lappend LesHitSysteme $Term }
if {[regexp -nocase "\[^a-z\]$Term\[^a-z\]" " $Abstract "]} { lappend LesHitSysteme $Term }
}
set LesHitSysteme [lsort -unique $LesHitSysteme]
set LesHitNecessaire {}
foreach Term $LesMotsNecessaires {
if {[regexp -nocase "\[^a-z\]$Term\[^a-z\]" " $Title "] } { lappend LesHitNecessaire $Term }
if {[regexp -nocase "\[^a-z\]$Term\[^a-z\]" " $Abstract "]} { lappend LesHitNecessaire $Term }
}
set LesHitNecessaire [lsort -unique $LesHitNecessaire]
puts ""
puts "$Pmid $PubYear $PubMonth $Title"
puts "I found $LesHitSysteme $LesHitNecessaire"
set HitsTrouves($Pmid) [join [concat $LesHitSysteme $LesHitNecessaire]]
}
set adresse "m.sissler@iecb.u-bordeaux.fr,luc.moulinier@unistra.fr,raymond.ripp@unistra.fr"
set sender "MiSynPat@$WebServer"
if {$Lnew != {}} {
set N [llength $Lnew]
set sujet ">> $N New article"
set corps "Hello !\n\n -> $N publication appears in the bibliographic system : Go to \nhttp://$WebServer/misynpat/BibliographyUpdate.rvt\n\n\nHave a good reading !"
foreach new $Lnew {
set Hits ""
if {[info exists HitsTrouves($new)]} { set Hits $HitsTrouves($new) }
Espionne "new PMID : $new $Hits"
$db eval {insert into biblio values (NULL,$new,-1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,$Hits)}
}
# Record new articles in db
AjouteEntreesBiblio $db
} else {
set sujet "From $WebServer : Nothing new in MiSynPat Bibliography."
set corps "Hello !\n\nFrom $WebServer : Nothing new in MiSynPat Bibliography.\n\nSee you tomorrow !"
}
# check for unseen articles
set NbUnseen [$db eval {select count(pk_biblio) from biblio where accepted = -1}]
$db close
if {$NbUnseen} {
append sujet " $NbUnseen unseen articles !"
set Message "BEWARE ! There are $NbUnseen articles that have not been processed !"
append corps "\n$Message\n"
puts $Message
}
send_simple_message $adresse localhost $sujet $corps $sender
exit
}
proc AjouteEntreesBiblio {{db ""}} {
if {$db==""} {
set Fichier "[MiSynPatDir]/misynpat.sql"
set db "root"
sqlite3 $db $Fichier
}
set LesOk {}
set pmids [$db eval {select pmid from biblio where accepted=-1}]
foreach pmid $pmids {
set Linfo [eFetchREST pubmed $pmid]
array set Tinfo $Linfo
Espionne $pmid
if { ! [info exists Tinfo($pmid,Title)] && ! [info exists Tinfo($pmid,Abstract)] && ! [info exists Tinfo($pmid,PubYear)]} {
Espionne "$pmid rien trouvé : Linfo $Linfo"
continue
}
lappend LesOk $pmid
set titre $Tinfo($pmid,Title)
set abstract $Tinfo($pmid,Abstract)
set year $Tinfo($pmid,PubYear)
set month ""
if {[info exists Tinfo($pmid,PubMonth)]} { set month $Tinfo($pmid,PubMonth) }
Espionne "$pmid $year $month $titre"
Espionne "$abstract"
set titre [string map {"'" "''"} $titre]
set abstract [string map {"'" "''"} $abstract]
$db eval {update biblio set abstract=$abstract,titre=$titre,datey=$year,datem=$month where pmid=$pmid}
Espionne $pmid remis à jour dans database
}
return $LesOk
}
proc MiseAJourEntreesBiblio {{db ""} {PmidsSpecifiques ""}} {
if {$db==""} {
package require sqlite3
set Fichier "[MiSynPatDir]/misynpat.sql"
set db "root"
sqlite3 $db $Fichier
}
set LesInfoDispo [list PubMonth Issue MeSHMinor Title LAuthors Abstract JrnAbbv MeSHMajor Volume PubYear Pages JrnName]
set Corre(Issue) ""
set Corre(MeSHMinor) ""
set Corre(MeSHMajor) ""
set Corre(JrnName) ""
set Corre(Title) titre
set Corre(Abstract) abstract
set Corre(JrnAbbv) sJournal
set Corre(LAuthors) auteurs
set Corre(Volume) volume
set Corre(PubYear) datey
set Corre(PubMonth) datem
set Corre(Pages) pages
set LesOk {}
if {$PmidsSpecifiques!=""} {
set pmids [split $PmidsSpecifiques ","]
} else {
set pmids [$db eval {select pmid from biblio}]
}
set pmids [lsort -unique $pmids]
foreach pmid $pmids {
set Tout [$db eval {select * from biblio where pmid=$pmid}]
foreach K [list Pmid Accepted Abstract Journal Auteurs Pages Mois Annee Titre Volume Hits] {
set $K ""
}
lassign $Tout Pk Pmid Accepted Abstract Journal Auteurs Pages Mois Annee Titre Volume Hits
set ToutOk 1
foreach K [list Pmid Accepted Abstract Auteurs Annee Titre] {
if {[set $K]==""} { set ToutOk 0 ; Espionne "$pmid $K" ; break }
}
if {$ToutOk} { continue }
Espionne "$pmid"
set Linfo [eFetchREST pubmed $pmid]
if {[info exists Tinfo]} { unset Tinfo }
array set Tinfo $Linfo
if { ! [info exists Tinfo($pmid,Title)] && ! [info exists Tinfo($pmid,Abstract)] && ! [info exists Tinfo($pmid,PubYear)]} {
continue
}
lappend LesOk $pmid
parray Tinfo
set LesUpdate {}
foreach I $LesInfoDispo {
if { ! [info exists Corre($I)] || $Corre($I)==""} { Espionne "pas de $I" ; continue }
if { ! [info exists Tinfo($pmid,$I)] } { Espionne "pas de info pour $I" ; continue }
set V $Tinfo($pmid,$I)
regsub -all "'" $V "''" V
lappend LesUpdate "$Corre($I)='$V'"
}
if {$LesUpdate!={}} {
set Update "update biblio set [join $LesUpdate ,] where pmid=$pmid"
Espionne $Update
}
$db eval $Update
}
return $LesOk
}
proc Editdb {} {
set Fichier "[MiSynPatDir]/misynpat.sql"
set db "root"
sqlite3 $db $Fichier
set pks [$db eval {select pk_synthetase from synthetase}]
foreach pk $pks {
$db eval {insert into jmol values ($pk,NULL,NULL,NULL,NULL,NULL)}
}
$db close
}
proc testdb {} {
set Fichier "[MiSynPatDir]/misynpat.sql"
set db "root"
sqlite3 $db $Fichier
set Nom "DARS2"
set Lfeat [$db eval {select seq from synthetase where sName=$Nom}]
set pk [$db eval {select pk_synthetase from synthetase where sName=$Nom}]
set muta [$db eval {select pk_mutation from mutation where pk_synthetase=$pk}]
set variant {}
foreach mut $muta {
set var1 [$db eval {select variant1 from mutation where pk_mutation=$mut}]
set var2 [$db eval {select variant2 from mutation where pk_mutation=$mut}]
if {$var1 ne "X1X" && $var1 ne "X2X" } {lappend variant "$var1"}
if {$var2 ne "X1X" && $var2 ne "X2X" } {lappend variant "$var2"}
}
regsub -all {[A-Z]} $variant {} variant
set variant [lsort -unique $variant]
set variant [join $variant ","]
set Lfeat [join $Lfeat ""]
set Lfeat [split $Lfeat ","]
foreach feat $Lfeat {
if {[regexp {'([0-9]+)'} $feat]} {continue}
regsub -all {'} $feat {} feat
set feats [split $feat " "]
set start [expr { round([lindex $feat 1]*0.25) }]
set stop [expr { round([lindex $feat 2]*0.25) }]
set lenrect [expr { round($stop-$start) }]
puts $lenrect
}
}
proc Testcode {} {
source /home/moumou/ordali/src/ordali_misynpat.tcl
set sys "dars2"
set pos "512"
set aa "P"
set retour [ComputeMiSynPatMutation $sys $pos $aa]
puts "$retour"
exit
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.