#rR gscope_retchip.tcl
proc TestCineticCongRD1 {} {
foreach GN [CineticCongRD1 ListOf GN] {
foreach Mot [split $GN ","] {
set GscopeId [QuestionDeScience "EVImm" "ret GscopeIdsOfGeneName $Mot WithSynonyms"]
Espionne "$Mot $GscopeId"
}
}
}
proc IsRetchip Nom {
set Retchip [ExtraitInfo $Nom "Retchip:"]
return [string equal -nocase $Retchip "Yes"]
}
proc MiseEnSequenceDeRetinoBase {} {
FaireLire "attention ne pas reexecuter cette procedure"; exit
CanalSqlRetinoBase
set LesTables [list analysissoftware arraytype cluster experiment genotype individual organism ortholog probeset ratio rawdata realexp sample treatment treatmenttype]
foreach Table $LesTables {
set NomPk "pk_${Table}"
if {$NomPk=="pk_analysissoftware"} { set NomPk "pk_software" }
set Last [SqlExec "select $NomPk from retinobase3.${Table} order by $NomPk desc limit 1" "GetFirstValue"]
if {$Last==""} { continue }
Espionne "$Table $Last"
set Sql "CREATE SEQUENCE retinobase3.${Table}_pk_${Table}_seq \
INCREMENT 1 \
MINVALUE 1 \
MAXVALUE 9223372036854775807 \
START $Last \
CACHE 1; \
ALTER TABLE retinobase3.${Table}_pk_${Table}_seq OWNER TO berthomg; \
GRANT ALL ON TABLE retinobase3.${Table}_pk_${Table}_seq TO berthomg; \
GRANT SELECT, INSERT, REFERENCES ON TABLE retinobase3.${Table}_pk_${Table}_seq TO guest; \
GRANT SELECT ON TABLE retinobase3.${Table}_pk_${Table}_seq TO hoan"
Espionne $Sql
SqlExec $Sql
}
}
proc CineticCongRD1Tissues {} {
CanalSqlRetinoBase
SqlExec "select set_curcfg('default');"
set LesTissues [list \
"retina = Ret" \
"MGC" \
"brain = BR" \
"testis" \
"cumulus_oocyte_complex" \
"ovary" \
"placenta" \
"aorta" \
"heart" \
"lung" \
"kidney" \
"liver" \
"spleen" \
"submax_gland" \
"thymus" \
"stomach" \
"lymph_node" \
"skeletal_muscle" \
"CD4+_naive" \
"embryo_d7"]
foreach Truc $LesTissues {
set Better ""
set Old ""
scan $Truc "%s %s %s" Name Better Old
if {$Old!=""} { continue }
if {$Better!=""} { set BetterName($Name) $Better ; set Name $Better }
set Pk [ProchainPk "retinobase3.tissue"]
regsub -all "_" $Name " " Description
set Sql "insert into retinobase3.tissue (pk_tissue, name, description) values ($Pk, '$Name', '$Description') ;"
Espionne $Sql
# SqlExec $Sql
}
CanalSqlDisconnect
}
proc CineticCongRD1Filter Liste {
set New {}
foreach Nom $Liste {
if {[info exists DejaVu($Nom)]} { continue }
set DejaVu($Nom) 1
if { ! [IsRetchip $Nom]} { continue }
lappend New $Nom
}
return $New
}
proc CineticCongRD1 {{Qui ""} {Quoi ""}} {
global CineticCongRD1
if {$Qui==""} { set Qui "ListOf" ; set Quoi "GoodHeader" }
if {[info exists CineticCongRD1($Qui,$Quoi)]} { return $CineticCongRD1($Qui,$Quoi) }
if {[info exists CineticCongRD1("EstCharge")]} {
if {$Qui=="SaveInFile"} {
set LesGoodHeader [CineticCongRD1 ListOf GoodHeader]
set Headers [join $LesGoodHeader "\t"]
set LaSortie {}
lappend LaSortie $Headers
foreach PS [CineticCongRD1 ListOf PS] {
set LaLigne {}
foreach H [CineticCongRD1 ListOf GoodHeader] {
lappend LaLigne [CineticCongRD1 $PS $H]
}
set Ligne [join $LaLigne "\t"]
lappend LaSortie $Ligne
}
set Fichier $Quoi
set Fichier [SauveLesLignes $LaSortie dans $Fichier]
return $Fichier
}
return ""
}
set CineticCongRD1("EstCharge") 1
#rR set FichierFred "[HomeRipp]/GenoretWww/Collaboration/CineticCongRD1/Additional_File_3-Table.csv"
set FichierFred "[HomeRipp]/GenoretWww/Collaboration/CineticCongRD1/Additional_File_3-Tablev3.csv"
set Q [file tail $FichierFred]
regsub -nocase {\.[^\.]+$} $Q "" Q
LoadTxlWithRowsOfCells $FichierFred Txl -1 ";"
set CineticCongRD1(File,Name) $FichierFred
set CineticCongRD1(File,Queue) $Q
# EspionneL $Txl(ListHeaderPlease,$Q)
set CineticCongRD1(ListOf,Header) $Txl(ListHeaderPlease,$Q)
set CineticCongRD1(ListOf,Index) $Txl(ListAllPlease,$Q)
set UnknownGN 0
foreach I $CineticCongRD1(ListOf,Index) {
set GN $Txl($I,GeneName)
if {$GN=="-"} { set GN "Unknown_[incr UnknownGN]" }
lappend CineticCongRD1(ListOf,GN) $GN
set PS $Txl($I,ID)
lappend CineticCongRD1(ListOf,PS) $PS
lappend CineticCongRD1($GN,ListOfPS) $PS
if {[info exists DejaVu($PS)]} { FaireLire "I found redondant probesets : $I $GN $PS" }
set DejaVu($PS) $I
set CineticCongRD1($PS,GN) $GN
foreach T $CineticCongRD1(ListOf,Header) {
set CineticCongRD1($I,$T) $Txl($I,$T)
set CineticCongRD1($PS,$T) $Txl($I,$T)
set CineticCongRD1($PS,Index) $I
}
}
set CineticCongRD1(ListOf,GN) [lsort -unique $CineticCongRD1(ListOf,GN)]
foreach GN $CineticCongRD1(ListOf,GN) {
foreach Mot [split $GN ","] {
if {[OnTraiteEVImm]} {
set GscopeIds [GscopeIdsOfGeneName $Mot "WithSynonymsRetChipOnly"]
set GscopeIds [CineticCongRD1Filter $GscopeIds]
} else {
set GscopeIds [QuestionDeScience "EVImm" "ret GscopeIdsOfGeneName $Mot WithSynonymsRetChipOnly"]
set GscopeIds [QuestionDeScience "EVImm" "ret CineticCongRD1Filter $GscopeIds"]
}
set CineticCongRD1($GN,GscopeIds) $GscopeIds
foreach PS $CineticCongRD1($GN,ListOfPS) {
set CineticCongRD1($PS,GscopeIds) $GscopeIds
set CineticCongRD1($PS,PS) $PS
set CineticCongRD1($PS,GN) $GN
}
}
}
set CineticCongRD1(ListOf,GoodHeader) [concat [list "PS" "GN" "GscopeIds"] $CineticCongRD1(ListOf,Header)]
return [CineticCongRD1 $Qui $Quoi]
}
proc SynonymsPourTous {{Liste ""} {Quoi ""} {GscopeSyn ""}} {
set GscopeSyn [string equal -nocase $GscopeSyn "GscopeSyn"]
set SynGscope [expr ! $GscopeSyn]
if {$Quoi==""} { set Quoi "GetList" }
if {$Liste==""} { set Liste [ListeDesPABs] }
if {$GscopeSyn} {
set LesGscopeSyn {}
foreach Nom $Liste {
lappend LesGscopeSyn "$Nom [join [SynonymsOfGscopeId $Nom] " "]"
}
if {$Quoi=="GetList"} { return $LesGscopeSyn }
set GscopeSyn [join $LesGscopeSyn "\n"]
if {[PourWscope]} {
return [Html_DuTexteTelQuel $GscopeSyn]
}
if {$Quoi=="GetTxt"} { return $GscopeSyn }
if {$Quoi=="Show"} { return [AfficheVariable $GscopeSyn] }
return $LesGscopeSyn
}
if {$SynGscope} {
set LesSynGscope {}
foreach Synonym [GscopeSynonyms ListOf Synonyms] {
lappend LesSynGscope "[format %-20s $Synonym] [join [GscopeSynonyms $Synonym GscopeIds] " "]"
}
if {$Quoi=="GetList"} { return $LesSynGscope }
set SynGscope [join $LesSynGscope "\n"]
if {[PourWscope]} {
return [Html_DuTexteTelQuel $SynGscope]
}
if {$Quoi=="GetTxt"} { return $SynGscope }
if {$Quoi=="Show"} { return [AfficheVariable $SynGscope] }
return $LesSynGscope
}
}
proc GscopeSynonyms {{Qui ""} {Quoi ""}} {
global GscopeSynonyms
if {$Qui==""} { set Qui "ListOf" }
if {$Quoi==""} { set Quoi "Synonyms" }
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists GscopeSynonyms($Qui,$Quoi)]} { return $GscopeSynonyms($Qui,$Quoi) }
if {[info exists GscopeSynonyms("EstCharge")]} { return "" }
set GscopeSynonyms("EstCharge") 1
set GscopeSynonyms(LISTOF,SYNONYMS) {}
foreach Nom [ListeDesPABs] {
set LesSyn [Synonyms $Nom]
foreach Syn $LesSyn {
set SYN [string toupper $Syn]
lappend GscopeSynonyms(LISTOF,SYNONYMS) $Syn
lappend GscopeSynonyms($SYN,GSCOPEIDS) $Nom
foreach S $LesSyn {
lappend GscopeSynonyms($SYN,SYNONYMS) $S
}
}
}
set GscopeSynonyms(LISTOF,SYNONYMS) [lsort -unique $GscopeSynonyms(LISTOF,SYNONYMS)]
foreach Syn $GscopeSynonyms(LISTOF,SYNONYMS) {
set SYN [string toupper $Syn]
set GscopeSynonyms($SYN,SYNONYMS) [ListeSansDoublon $GscopeSynonyms($SYN,SYNONYMS) "" "NoEmpty"]
}
return [GscopeSynonyms $Qui $Quoi]
}
proc Synonyms Nom {
return [SynonymsOfGscopeId $Nom]
}
proc SynonymsOfGscopeId Nom {
set GN [ValiGN $Nom]
set Alias [Alias $Nom]
if {$GN==""} { set GN $Alias }
if {$GN==""} { return {} }
set FromGscope [list $GN $Alias]
set FromSameOrga [SynonymsFromSameOrganism $GN]
set LesSynonymes [concat $FromGscope $FromSameOrga]
set LesSynonymes [ListeSansDoublon $LesSynonymes "" "NoEmpty"]
return $LesSynonymes
}
proc SynonymsFromSameOrganism {G {Programme ""}} {
while {$Programme==""} {
set OS [NotreOS]
if {$OS=="Homo sapiens"} { set Programme "HumanSynonyms" ; break }
if {$OS=="Mus musculus"} { set Programme "MouseSynonyms" ; break }
if {[PourWscope]} { return "" }
set Programme [ChoixParmi [list "MouseSynonyms" "HumanSynonyms"]]
if {$Programme==""} { return "" }
}
if {$G=="NameOfProgram"} { return $Programme }
return [$Programme $G]
}
proc MouseSynonyms G {
set M [MGI $G "MgiId"]
if {$M==""} { return {} }
set O [MGI $M "GeneName"]
set All [concat [list $O] [MGI $M "Synonyms"]]
set All [ListeSansDoublon $All]
return $All
}
proc HumanSynonyms G {
set H [HGNC $G "HGNC_ID"]
if {$H==""} { return {} }
set O [HGNC $H "Approved_Symbol"]
set All [concat [list $O] [HGNC $H "Synonyms"]]
set All [ListeSansDoublon $All]
return $All
}
proc MouseFromHuman {{Qui ""} {Quoi ""}} {
if {$Qui==""} { set Qui "ListOf" }
if {[string equal -nocase $Qui "ListOf"]} {
if {[string equal -nocase $Quoi "HumanHeader"]} { return [HGNC ListOf Header] }
if {[string equal -nocase $Quoi "MouseHeader"]} { return [MGI ListOf Header] }
}
set H [HGNC $Qui HGNC_ID]
Espionne "H $H"
set M [MGIHGNC $H MGIID]
Espionne "M $M"
if {$M==""} { set M [MGIHGNC $Qui MGIID] }
return [MGI $M $Quoi]
}
proc HumanFromMouse {{Qui ""} {Quoi ""}} {
if {$Qui==""} { set Qui "ListOf" }
if {[string equal -nocase $Qui "ListOf"]} {
if {[string equal -nocase $Quoi "MouseHeader"]} { return [MGI ListOf Header] }
if {[string equal -nocase $Quoi "HumanHeader"]} { return [HGNC ListOf Header] }
}
set M [MGI $Qui MGIID]
Espionne "M $M"
set H [MGIHGNC $M HGNCID]
Espionne "H $H"
if {$H==""} { set H [MGIHGNC $Qui HGNCID] }
if {$H==""} { set H [HGNC $Qui HGNC_ID]}
return [HGNC $H $Quoi]
}
proc MGIHGNC {{Qui ""} {Quoi ""}} {
global MGIHGNC
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" }
if {$Quoi==""} { set Quoi "AllTxt" }
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists MGIHGNC($Qui,$Quoi)]} { return $MGIHGNC($Qui,$Quoi) }
if {$Quoi=="ALLTXT" || $Quoi=="ALLLIST" || $Quoi=="ALLHTML"} {
set LeTout [MGIHGNC $Qui "All"]
if {$LeTout==""} { return "" }
foreach T [MGIHGNC ListOf Header] V $LeTout {
lappend LeRetour [format "%45s : %s" $T $V]
}
if {$Quoi=="ALLLIST"} { return $LeRetour }
set Retour [join $LeRetour "\n"]
if {$Quoi=="ALLHTML" || [PourWscope]} {
return "\n$Retour\n
"
}
if {$Quoi=="ALLTXT"} { return $Retour }
return $Retour
}
if {[info exists MGIHGNC("EstCharge")]} {
if {[info exists MGIHGNC($Qui,MGIID)]} {
set FirstRef [lindex $MGIHGNC($Qui,MGIID) 0]
if {[string equal -nocase $Qui $FirstRef]} { return "" }
return [MGIHGNC $FirstRef $Quoi]
}
return ""
}
set MGIHGNC("EstCharge") 1
set FichierMGIHGNC "[GscopeDatabaseDir UCSCGenomes]/GeneNaming/HMD_HGNC_Accession.rpt"
set Q [file tail $FichierMGIHGNC]
set MGIHGNC(FILE,NAME) $FichierMGIHGNC
set MGIHGNC(FILE,QUEUE) $Q
set MGIHGNC(LISTOF,HEADER) [list "MgiId" "MgiGeneName" "MgiMarkerName" "MgiEntrezGeneId" "HgncId" "HgncGeneName" "HgncEntrezGeneId"]
foreach Ligne [LesLignesDuFichier $FichierMGIHGNC] {
set LesMots [split $Ligne "\t"]
ScanLaListe $LesMots MgiId MgiGeneName MgiMarkerName MgiEntrezGeneId HgncId HgncGeneName HgncEntrezGeneId
set MGIID [string toupper $MgiId]
set HGNCID [string toupper $HgncId]
set MGIGENENAME [string toupper $MgiGeneName]
set HGNCGENENAME [string toupper $HgncGeneName]
#if {$HGNCID!="" && [info exists DejaVu($HGNCID)]} { FaireLire "DejaVu $HGNCID\n$DejaVu($HGNCID)\n$Ligne" }
#set DejaVu($HGNCID) $Ligne
#if {$MGIID!="" && [info exists DejaVu($MGIID)]} { FaireLire "DejaVu $MGIID\n$DejaVu($MGIID)\n$Ligne" }
#set DejaVu($MGIID) $Ligne
foreach T $MGIHGNC(LISTOF,HEADER) V $LesMots {
set T [string toupper $T]
set MGIHGNC($MGIID,$T) $V
set MGIHGNC($HGNCID,$T) $V
}
set MGIHGNC($MGIID,HGNCID) $HGNCID
set MGIHGNC($HGNCID,MGIID) $MGIID
lappend MGIHGNC($MGIGENENAME,MGIID) $MGIID
lappend MGIHGNC($HGNCGENENAME,HGNCID) $HGNCID
lappend MGIHGNC($MgiEntrezGeneId,HGNCGENEID) $HgncEntrezGeneId
lappend MGIHGNC($HgncEntrezGeneId,MGIGENEID) $MgiEntrezGeneId
lappend MGIHGNC($HgncEntrezGeneId,MGIID) $MGIID
lappend MGIHGNC(LISTOF,MGIID) $MGIID
lappend MGIHGNC(LISTOF,HGNCID) $HGNCID
lappend MGIHGNC(LISTOF,MGIGENENAME) $MGIGENENAME
lappend MGIHGNC(LISTOF,HGNCGENENAME) $HGNCGENENAME
set MGIHGNC($MGIID,ALL) $LesMots
set MGIHGNC($HGNCID,ALL) $LesMots
}
set MGIHGNC(LISTOF,MGIID) [lsort -unique $MGIHGNC(LISTOF,MGIID)]
set MGIHGNC(LISTOF,HGNCID) [lsort -unique $MGIHGNC(LISTOF,HGNCID)]
set MGIHGNC(LISTOF,MGIGENENAME) [lsort -unique $MGIHGNC(LISTOF,MGIGENENAME)]
set MGIHGNC(LISTOF,HGNCGENENAME) [lsort -unique $MGIHGNC(LISTOF,HGNCGENENAME)]
return [MGIHGNC $Qui $Quoi]
}
proc MGI {{Qui ""} {Quoi ""}} {
#LP 2013/01/31 avant on lisait MRK_Synonym.sql.rpt. Maintenant on lit MRK_List2.rpt
global MGI
if {$Qui==""} { set Qui "ListOf" }
if {$Quoi=="" && [string equal -nocase $Qui "ListOf"]} { set Quoi "Header" }
if {$Quoi==""} { set Quoi "AllTxt" }
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {[info exists MGI($Qui,$Quoi)]} { return $MGI($Qui,$Quoi) }
if {$Quoi=="ALLTXT" || $Quoi=="ALLLIST" || $Quoi=="ALLHTML"} {
set LesTouts [MGI $Qui All]
set LeRetour {}
set N [llength $LesTouts]
set Saut ""
if {$N>1} {
set Saut "\n"
}
set I 0
foreach LeTout $LesTouts {
incr I
if {$LeTout==""} { continue }
if {$N>1} { lappend LeRetour [format "\n%45s : %s" "I_found_${N}_hits" $I] }
foreach T [MGI ListOf Header] V $LeTout {
lappend LeRetour [format "%45s : %s" $T $V]
}
}
if {$Quoi=="ALLLIST"} { return $LeRetour }
set Retour [join $LeRetour "\n"]
if {$Quoi=="ALLHTML" || [PourWscope]} {
return "\n$Retour\n
"
}
if {$Quoi=="ALLTXT"} { return $Retour }
return $Retour
}
if {[info exists MGI("EstCharge")]} {
if {[info exists MGI($Qui,ONE_MGIID)]} {
return [MGI $MGI($Qui,ONE_MGIID) $Quoi]
}
return ""
}
set MGI("EstCharge") 1
set FichierMGI "[GscopeDatabaseDir UCSCGenomes]/GeneNaming/MRK_List2.rpt"
set Q [file tail $FichierMGI]
regsub -nocase {\.[^\.]+$} $Q "" Q
set MGI(FILE,NAME) $FichierMGI
set MGI(FILE,QUEUE) $Q
LoadTxl $FichierMGI Txl -1 "\t"
set MGI(LISTOF,HEADER) $Txl(ListHeaderPlease,$Q)
set MGI(LISTOF,INDEX) $Txl(ListAllPlease,$Q)
foreach I $Txl(ListAllPlease,$Q) {
set MgiId $Txl($I,MGI_Accession_ID)
set Gn $Txl($I,Marker_Symbol)
if {[info exists Txl($I,Marker_Synonyms_pipe-separated)]} {
set SynIni $Txl($I,Marker_Synonyms_pipe-separated)
}
set MGIID [string toupper $MgiId]
set GN [string toupper $Gn]
lappend MGI(LISTOF,MGIID) $MgiId
lappend MGI(LISTOF,GENENAME) $Gn
set MGI($GN,MGIID) [lsort -unique [lappend MGI($GN,MGIID) $MgiId]]
set MGI($MGIID,GENENAME) [lsort -unique [lappend MGI($MGIID,GENENAME) $Gn]]
if {[info exists SynIni]} {
set LesSyn [split $SynIni "|"]
set MGI($MGIID,LISTOFSYN) $LesSyn
set MGI($GN,LISTOFSYN) $LesSyn
foreach Syn $LesSyn {
set SYN [string toupper $Syn]
lappend MGI($SYN,REFERENCE_MGIID) $MGIID
lappend MGI($SYN,REFERENCE_GENENAME) $Gn
}
}
set LeTout {}
foreach T $Txl(ListHeaderPlease,$Q) {
lappend LeTout $Txl($I,$T)
set MGI($MGIID,[string toupper $T]) $Txl($I,$T)
set MGI($GN,[string toupper $T]) $Txl($I,$T)
}
lappend MGI($MGIID,ALL) $LeTout
lappend MGI($GN,ALL) $LeTout
}
set MGI(LISTOF,MGIID) [lsort -unique $MGI(LISTOF,MGIID)]
set MGI(LISTOF,GENENAME) [lsort -unique $MGI(LISTOF,GENENAME)]
return [MGI $Qui $Quoi]
}
proc MGISW {{Qui ""} {Quoi ""} {Ou ""}} {
JeMeSignale
#Utilise l'un ou l'autre
#set FichierMGISW "/genomics/link/UCSCGenomes/GeneNaming/MRK_SwissProt.rpt"
#set FichierMGISW "/genomics/link/UCSCGenomes/GeneNaming/MRK_SwissProt_TrEMBL.rpt"
global MGISW
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Header" }
if {$Quoi==""} { set Quoi "AllTxt" }
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
Espionne $Ou
if {[string equal -nocase $Ou "SW"]} { set Ou "MRK_SwissProt.rpt" }
if {[string equal -nocase $Ou "SWTrEmbl"]} { set Ou "MRK_SwissProt_TrEMBL.rpt" }
if {$Ou!="" && ! [regexp "/" $Ou]} { set Ou "/genomics/link/UCSCGenomes/GeneNaming/$Ou" }
Espionne $Ou
if {$Ou!=""} {
if {[info exists MGISW(FILE,NAME)] && $Ou!=$MGISW(FILE,NAME)} {
unset MGISW
}
set FichierMGISW $Ou
set MGISW(FILE,NAME) $Ou
} else {
if {[info exists MGISW(FILE,NAME)]} {
set Ou $MGISW(FILE,NAME)
set FichierMGISW $Ou
} else {
FaireLire "Il faut donner un nom de fichier ou SW ou SWTrEmbl la premiere fois"
return ""
}
}
if {[info exists MGISW($Qui,$Quoi)]} { return $MGISW($Qui,$Quoi) }
if {$Quoi=="ALLTXT" || $Quoi=="ALLLIST" || $Quoi=="ALLHTML"} {
set LeTout [MGISW $Qui "All"]
if {$LeTout==""} { return "" }
foreach T [MGISW ListOf Header] V $LeTout {
lappend LeRetour [format "%45s : %s" $T $V]
}
if {$Quoi=="ALLLIST"} { return $LeRetour }
set Retour [join $LeRetour "\n"]
if {$Quoi=="ALLHTML" || [PourWscope]} {
return "\n$Retour\n
"
}
if {$Quoi=="ALLTXT"} {
return $Retour
}
return $Retour
}
if {[info exists MGISW("EstCharge")]} {
if {[info exists MGISW($Qui,MGIID)]} {
set FirstRef [lindex $MGISW($Qui,MGIID) 0]
if {[string equal -nocase $Qui $FirstRef]} { return "" }
return [MGISW $FirstRef $Quoi]
}
return ""
}
set MGISW("EstCharge") 1
set Q [file tail $FichierMGISW]
set MGISW(FILE,NAME) $FichierMGISW
set MGISW(FILE,QUEUE) $Q
set MGISW(LISTOF,HEADER) [list "MgiId" "GeneName" "Status" "Name" "cMPosition" "Chr" "Sw"]
foreach Ligne [LesLignesDuFichier $FichierMGISW] {
set LesMots [split $Ligne "\t"]
ScanLaListe $LesMots MgiId GeneName Status Name cMPosition Chr Sw
set MGIID [string toupper $MgiId]
set GENENAME [string toupper $GeneName]
lappend MGISW(LISTOF,MGIID) $MGIID
lappend MGISW(LISTOF,GENENAME) $GENENAME
if {$MGIID!="" && [info exists DejaVu($MGIID)]} { FaireLire "DejaVu $MGIID\n$DejaVu($MGIID)\n$Ligne" }
set DejaVu($MGIID) $Ligne
if {$GENENAME!="" && [info exists DejaVu($GENENAME)]} { FaireLire "DejaVu $GENENAME\n$DejaVu($GENENAME)\n$Ligne" }
set DejaVu($GENENAME) $Ligne
foreach T $MGISW(LISTOF,HEADER) V $LesMots {
set T [string toupper $T]
set MGISW($MGIID,$T) $V
set MGISW($GENENAME,$T) $V
}
set MGISW($MGIID,SW) $Sw
set MGISW($MGIID,ALL) $LesMots
}
set MGISW(LISTOF,MGIID) [lsort -unique $MGISW(LISTOF,MGIID)]
set MGISW(LISTOF,GENENAME) [lsort -unique $MGISW(LISTOF,GENENAME)]
return [MGISW $Qui $Quoi]
}
proc MGILP {{Qui ""} {Quoi ""}} {
#From LP: En 2008, tous les MGI n etaient pas present dans [GscopeDatabaseDir UCSCGenomes]/GeneNaming/MRK_Synonym.sql.rpt ??? exemple:ccng2
#FromLP: En 2013, le fichier MRK_Synonym.sql.rpt n existe plus : ne se sert plus de MGILP
global MGILP
set Qui [string toupper $Qui]
if {[info exists MGILP($Qui,$Quoi)]} {return $MGILP($Qui,$Quoi)}
if {[info exists MGILP("EstCharge")]} {return ""}
set MGILP("EstCharge") 1
#set MGILP(LISTOF,HEADER) [list "MgiId" "GeneName"]
set Fichier "[GscopeDatabaseDir UCSCGenomes]/GeneNaming/MRK_Dump1.rpt"
foreach Ligne [LesLignesDuFichier $Fichier] {
set LesMotsDeLaLigne [split $Ligne "\t"]
set Mgi [lindex $LesMotsDeLaLigne 0]
set Gn [lindex $LesMotsDeLaLigne 1]
set Gn [string toupper $Gn]
set MGILP($Mgi,Gn) $Gn
set MGILP($Gn,Mgi) $Mgi
}
return [MGILP $Qui $Quoi]
}
proc HGNC {{Qui ""} {Quoi ""}} {
global HGNC
if {[string equal -nocase $Quoi "GeneName"]} { set Quoi "Approved_Symbol" }
if {$Qui==""} { set Qui "ListOf" }
if {$Quoi=="" && [string equal -nocase $Qui "ListOf"]} { set Quoi "Header" }
if {$Quoi==""} { set Quoi "AllTxt" }
set Qui [string toupper $Qui]
set Quoi [string toupper $Quoi]
if {$Quoi=="ALLTXT" || $Quoi=="ALLLIST" || $Quoi=="ALLHTML"} {
set LeTout [HGNC $Qui All]
if {$LeTout==""} { return "" }
foreach T [HGNC ListOf Header] V $LeTout {
lappend LeRetour [format "%45s : %s" $T $V]
}
if {$Quoi=="ALLLIST"} { return $LeRetour }
set Retour [join $LeRetour "\n"]
if {$Quoi=="ALLHTML" || [PourWscope]} {
return "\n$Retour\n
"
}
if {$Quoi=="ALLTXT"} { return $Retour }
return $Retour
}
if {[info exists HGNC($Qui,$Quoi)]} { return $HGNC($Qui,$Quoi) }
if {[info exists HGNC("EstCharge")]} {
if {[info exists HGNC($Qui,REFERENCES)]} {
set FirstRef [lindex $HGNC($Qui,REFERENCES) 0]
return [HGNC $FirstRef $Quoi]
}
return ""
}
set HGNC("EstCharge") 1
set FichierHGNC "[GscopeDatabaseDir UCSCGenomes]/GeneNaming/HGNC.txt"
set Q [file tail $FichierHGNC]
regsub -nocase {\.[^\.]+$} $Q "" Q
LoadTxl $FichierHGNC Txl -1 "\t"
set HGNC(FILE,NAME) $FichierHGNC
set HGNC(FILE,QUEUE) $Q
set HGNC(LISTOF,HEADER) $Txl(ListHeaderPlease,$Q)
lappend HGNC(LISTOF,HEADER) "Source_of_information"
lappend HGNC(LISTOF,HEADER) "HttpReference"
set HGNC(LISTOF,INDEX) $Txl(ListAllPlease,$Q)
foreach I $Txl(ListAllPlease,$Q) {
set HGNCID "$Txl($I,HGNC_ID)"
if { ! [regexp {^HGNC\:} $HGNCID]} { set HGNCID "HGNC:$HGNCID" }
set Txl($I,HGNC_ID) $HGNCID
set AS $Txl($I,Approved_Symbol)
if {[info exists Txl($I,Aliases)]} { set Aliases $Txl($I,Aliases) }
if {[info exists Txl($I,Synonyms)]} { set Aliases $Txl($I,Synonyms) }
lappend HGNC(LISTOF,SYNOTXT) $Aliases
set Previous $Txl($I,Previous_Symbols)
set HGNC($AS,HGNC_ID) $I
if {[info exists DejaVu($AS)]} { FaireLire "I saw already $AS $I $DejaVu($AS)" }
set DejaVu($AS) $I
lappend HGNC(LISTOF,APPROVED_SYMBOL) $AS
set LesAlias [split $Aliases ","]
set LesPrevious [split $Previous ","]
set LesAliasEtPrevious [lsort -unique [concat $LesAlias $LesPrevious]]
set HGNC($HGNCID,SYNONYMS) {}
foreach Alias $LesAliasEtPrevious {
regsub -all " " $Alias "" Alias
lappend HGNC($HGNCID,LISTOFSYNONYM) $Alias
lappend HGNC($AS,LISTOFSYNONYM) $Alias
set ALIAS [string toupper $Alias]
lappend HGNC($ALIAS,REFERENCES) $HGNCID
lappend HGNC(LISTOF,ALIAS) $Alias
}
set LeTout {}
foreach T $Txl(ListHeaderPlease,$Q) {
lappend LeTout $Txl($I,$T)
set HGNC($HGNCID,[string toupper $T]) $Txl($I,$T)
set HGNC($AS,[string toupper $T]) $Txl($I,$T)
}
set HGNC($HGNCID,SOURCE_OF_INFORMATION) "Created by Gscope with download from http://www.genenames.org"
lappend LeTout $HGNC($HGNCID,SOURCE_OF_INFORMATION)
regsub -all {[^0-9]} $HGNCID "" HGNCIDnu
set Ref "http://www.genenames.org/data/hgnc_data.php?hgnc_id=$HGNCIDnu"
set TexteRef $Ref
if {[PourWscope]} { set TexteRef "$Ref" }
set HGNC($HGNCID,HTTPREFERENCE) $TexteRef
lappend LeTout $HGNC($HGNCID,HTTPREFERENCE)
set HGNC($HGNCID,ALL) $LeTout
set HGNC($AS,ALL) $LeTout
lappend HGNC(LISTOF,HGNC_ID) $HGNCID
}
set HGNC(LISTOF,SYNOTXT) [lsort -unique $HGNC(LISTOF,SYNOTXT)]
set HGNC(LISTOF,ALIAS) [lsort -unique $HGNC(LISTOF,ALIAS)]
set HGNC(LISTOF,SYNONYM) $HGNC(LISTOF,ALIAS)
return [HGNC $Qui $Quoi]
}
proc TestGenoretProteomicsLinks {} {
set Nom EVI00520
foreach Ref [GenoretProteomicsLinks $Nom "Ref"] {
Espionne $Ref
EspionneL [GenoretProteomicsLinks "$Nom$Ref" "Columns"]
}
exit
}
proc GenoretProteomicsLinks {{Qui ""} {Quoi ""}} {
global GenoretProteomicsLinks
if {$Qui == "Reset" && [info exists GenoretProteomicsLinks]} { unset GenoretProteomicsLinks ; return "" }
if {$Qui==""} { set Qui "ListOf"; set Quoi "EVI" }
if {$Quoi == ""} { set Quoi "All" }
if {[info exists GenoretProteomicsLinks($Qui,$Quoi)]} { return $GenoretProteomicsLinks($Qui,$Quoi) }
if {[info exists GenoretProteomicsLinks("EstCharge")]} { return "" }
set GenoretProteomicsLinks("EstCharge") 1
set GenoretProteomicsLinks(ListOf,EVI) {}
foreach Ligne [LesLignesDuFichier "[HomeRipp]/GenoretWww/Proteomics/GenoretGenesLinks.txt"] {
scan $Ligne "%s %s" Nom Queue
regsub { " $Ligne]} {
lappend LeTFA $Ligne
continue
}
if { ! $PremiereFois} {
# Espionne "Sauve dans $Nom"
# SauveLesLignes $LeTFA dans "[RepertoireDuGenome]/nuctfa/$Nom"
}
regsub ">" $Ligne "" Ligne
if {[regexp "bidon" $Ligne] && ! $YaEuLigne} { FaireLire "Un bidon sans ligne !!!" ; continue }
set PtiNom ""
if { 0==$Ieme } { set NewNum [expr $N ] ; set NewNom [format "EVI%5.5d" $NewNum] }
if { 0 <$Ieme && $Ieme < 10} { set NewNum [expr $N + $Ieme] ; set NewNom [format "EVI%5.5d" $NewNum] }
if {10<=$Ieme } { set NewNum [expr $N*100 + $Ieme] ; set NewNom [format "EVI%7.7d" $NewNum] }
if {10<=$Ieme } { set PtiNum [expr $N+50000 + $Ieme] ; set PtiNom [format "EVI%5.5d" $PtiNum] }
if {$PtiNom!="" && [info exists DejaVu($PtiNom)]} { Espionne "........................................... $PtiNom par $DejaVu($PtiNom)" }
set DejaVu($PtiNom) $NewNom
set I 0
set NomDeBase [format "EVI%5.5d" [expr $N]]
while 1 {
set Nom [format "EVI%5.5d" [expr $N+$I]]
if { ! [info exists DejaVu($Nom)]} { break }
incr I
}
set DejaVu($Nom) 1
set Tout 1
if {$Tout || $Nom!=$NewNom} {
set NewNomDe($Nom) $NewNom
set PlaceLibre [expr [string equal $Nom $NewNom] || [string length $NewNom]>8 || [info exists NewNomDe($NewNom)]]
set Texte "$Nom [format "%-10s" $NewNom] [format "%2d" $Ieme] $N $PlaceLibre $PtiNom"
Espionne $Texte
lappend LaCorrespondance "$Nom [expr $N/10] $Ieme"
}
incr Ieme
continue
if {$YaEuLigne && [info exists BonNom($Nom)]} {
Espionne "$Nom devrait s'appeler $BonNom($Nom)"
}
if {(0<$I && $I<10) && $PrecedentMerde} {
Espionne " ............................... $Nom"
}
if {$I>9 || $PrecedentMerde} {
set Normal 0
set BeauNom [format "EVI%7.7d" [expr $N*100 + $I]]
if {$YaEuLigne} {
set MeilleurN [expr $N]
set MeilleurNom [format "EVI%5.5d" [expr $MeilleurN]]
Espionne "$Nom != $BeauNom mais $MeilleurNom"
set PrecedentMerde 1
} else {
Espionne "$Nom == $BeauNom"
set PrecedentMerde 0
}
set NbDizaines [expr $I/10]
while {$NbDizaines>0} {
set Pousse [format "EVI%5.5d" [expr $N + $NbDizaines*10]]
# set MauvaisNomDuPousse($Pousse) [format "EVI%5.5d" [expr $N + $I + 1]]
# set MauvaisNomPrecedent [format "EVI%5.5d" [expr $N + $I]]
# if {[info exists BonNom($MauvaisNomPrecedent)]} { unset BonNom($MauvaisNomPrecedent) }
set Decalage 0
set MauvaisNom [format "EVI%5.5d" [expr $Decalage + $N + $I + 1]]
set BonNom($MauvaisNom) $Pousse
incr NbDizaines -1
continue
}
}
set YaEuLigne 0
continue
}
SauveLesLignes $LaCorrespondance dans "[Fiches]/NomLigne.txt"
exit
}
proc CompteLesPlusDixAccmRNA {} {
set NumeroLigne ""
set NbDeFois 0
set Trop 0
set OnALigne 0
foreach Ligne [LesLignesDuFichier "/genomics/link/EVImm/parser/AttriToutVf2"] {
if {[regexp "^ligne" $Ligne]} {
set OnALigne 1
if {$NbDeFois>10} {
Espionne "$NumeroLigne $NbDeFois"
incr Trop
}
set NbDeFois 0
scan $Ligne "%s %s" Bidon NumeroLigne
}
if {$OnALigne && [regexp "^>" $Ligne]} {
incr NbDeFois
}
}
Espionne "trop $Trop"
}
proc CompulsoryGenesOnWeb {} {
return [RetinalGenesSummaryOnWeb [ListOfCompulsoryGenes] "CompulsoryGenes"]
}
proc CorrigeLesBestCops {} {
set Compte 0
set DeCompte 100
foreach Fichier [lsort [glob "[RepertoireDuGenome]/transcriptomique/LesCopainsClusterOld/*lesbestcops"]] {
if { ! [incr DeCompte -1]} { Espionne "[incr Compte] $Fichier"; set DeCompte 100 }
set Queue [file tail $Fichier]
regsub {\-lesbestcops} $Queue "" Queue
regsub {\-} $Queue {\\-} QX
set LesAutres {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp "nbdecombinaison" $Ligne]} {set Nlu [IntegerApres "nbdecombinaison" dans $Ligne] ; continue}
regsub -all "/" $Ligne "-OU-" Ligne
if {[regexp "$QX " $Ligne]} {
set MoiMeme $Ligne
scan $MoiMeme "%d" N
if {$Nlu!=$N} { FaireLire "$Queue $N $Nlu $Ligne" }
continue
}
lappend LesAutres $Ligne
}
set LeNouveau [list $MoiMeme]
LConcat LeNouveau $LesAutres
SauveLesLignes $LeNouveau dans $Fichier
}
}
proc CopainsDuBlastpEVImmProt {} {
foreach Nom [ListeDesPABs] {
set Fichier [GscopeFile $Nom "blastpEVImmProt"]
if {[FileAbsent $Fichier]} { continue }
set lBanqueId {}
set lPN {}
DecortiqueBlast $Fichier 1.0e-80 20 Query lBanqueId lAccess lDE lProfil lPN
set SeqRef [QueLaSequenceDuFichierTFA [GscopeFile $Nom "prottfa"]]
foreach BId $lBanqueId PN $lPN {
set Hit ""
regsub {^[^\:]+\:} $BId "" Hit
if {$Hit==$Nom || $Hit==""} { continue }
set SeqHit [QueLaSequenceDuFichierTFA [GscopeFile $Hit "prottfa"]]
if {[string equal -nocase $SeqHit $SeqRef]} {
lappend LesEgaux "$Hit = $Nom"
Espionne "$Hit = $Nom"
continue
}
if {[regexp -nocase $SeqHit $SeqRef]} {
lappend LesPetits "$Hit < $Nom"
continue
}
if {[regexp -nocase $SeqRef $SeqHit]} {
lappend LesPetits "$Nom < $Hit"
continue
}
}
}
set LesEgaux [lsort -unique $LesEgaux]
set LesPetits [lsort -unique $LesPetits]
SauveLesLignes $LesEgaux dans "[Fiches]/LesEgaux"
SauveLesLignes $LesPetits dans "[Fiches]/LesPetits"
return [concat $LesEgaux $LesPetits]
}
proc NiceWebOfCluster Texte {
set Liste {}
foreach Ligne [split $Texte "\n"] {
set GN ""
scan $Ligne "%d %s %s" N Queue GN
regsub {\-} $Queue " " NomProbeset
scan $NomProbeset "%s %s" Nom Probeset
set DE [DefinitionRapide $Nom]
lappend Liste $Nom
lappend LesPS $Probeset
lappend LesN $N
}
return [RetinalGenesSummaryOnWeb $Liste "BestFriendsInCluster" 1_ProbeSet $LesPS 1_ClusterHit $LesN ]
}
proc TranscriptomicBestFriendsInClusterDir {} {
return "[RepertoireDuGenome]/transcriptomique/LesCopainsCluster"
}
proc TranscriptomicBestFriendsInCluster {Nom {Quoi ""} {Comment ""}} {
set Extension "-lesbestcops"
if {$Comment==""} { set Comment "FileContent" }
if {$Quoi==""} { set Quoi "All"}
set Fichier "[TranscriptomicBestFriendsInClusterDir]/${Nom}-$Quoi$Extension"
if {[FileExists $Fichier]} {
if {$Comment=="FileContent"} { return [ContenuDuFichier $Fichier] }
if {$Comment=="NiceWeb"} { return [NiceWebOfCluster [ContenuDuFichier $Fichier]] }
}
if {$Quoi!="Filenames" || $Quoi!="All"} { return "" }
set Probesets [ExtraitInfo $Nom "ProbeSetId:"]
regsub -all "/" $Probesets "-OU-" Probesets
regsub -all "," $Probesets " " Probesets
set LesPS [LesMotsDeLaLigne $Probesets]
set LaSortie {}
foreach PS $LesPS {
set Fichier "[TranscriptomicBestFriendsInClusterDir]/$Nom-$PS$Extension"
if {[FileAbsent $Fichier]} {continue}
if {$Quoi=="FileNames"} { lappend LaSortie $Fichier }
if {$Quoi=="All"} { lappend LaSortie [ContenuDuFichier $Fichier] }
}
return [join $LaSortie "\n"]
}
proc TranscriptomicClustersDir {} {
return "[RepertoireDuGenome]/transcriptomique/cluster"
}
proc TranscriptomicClusters {Nom {Quoi ""}} {
if {$Quoi==""} { set Quoi "All"}
set Fichier "[TranscriptomicClustersDir]/${Nom}_$Quoi"
if {[FileExists $Fichier]} { return [ContenuDuFichier $Fichier] }
set Probesets [ExtraitInfo $Nom "ProbeSetId:"]
regsub -all "/" $Probesets "-OU-" Probesets
regsub -all "," $Probesets " " Probesets
set LesPS [LesMotsDeLaLigne $Probesets]
set LaSortie {}
foreach PS $LesPS {
set Fichier "[TranscriptomicClustersDir]/$Nom-$PS"
if {[FileAbsent $Fichier]} {continue}
if {$Quoi=="FileNames"} { lappend LaSortie $Fichier }
if {$Quoi=="All"} { lappend LaSortie [ContenuDuFichier $Fichier] }
}
return [join $LaSortie "\n"]
}
proc SignalIntensityDir {} {
return "[RepertoireDuGenome]/transcriptomique/SignalIntensity"
}
proc SignalIntensities {Nom {Quoi ""}} {
if {$Quoi==""} { set Quoi "All"}
set Fichier "[SignalIntensityDir]/${Nom}_$Quoi"
if {[FileExists $Fichier]} { return [ContenuDuFichier $Fichier] }
set Probesets [ExtraitInfo $Nom "ProbeSetId:"]
regsub -all "/" $Probesets "-OU-" Probesets
regsub -all "," $Probesets " " Probesets
set LesPS [LesMotsDeLaLigne $Probesets]
set LaSortie {}
foreach PS $LesPS {
set Fichier "[SignalIntensityDir]/$Nom-$PS"
if {[FileAbsent $Fichier]} {continue}
if {$Quoi=="FileNames"} { lappend LaSortie $Fichier }
if {$Quoi=="All"} { lappend LaSortie [ContenuDuFichier $Fichier] }
}
return [join $LaSortie "\n"]
}
proc GscopeIdsOfIdAccProt {Iap} {
global GscopeIdsOfIdAccProt
set IAP [string toupper $Iap]
if {[info exists GscopeIdsOfIdAccProt($IAP)]} { return $GscopeIdsOfIdAccProt($IAP) }
if {[info exists GscopeIdsOfIdAccProt("EstCharge")]} { return {} }
set GscopeIdsOfIdAccProt("EstCharge") 1
foreach Nom [ListeDesPABs] {
foreach IapLu [split [ExtraitInfo $Nom "IdAccProt:"] " "] {
set IapLu [string trim $IapLu]
set IAPLU [string toupper $IapLu]
lappend GscopeIdsOfIdAccProt($IAPLU) $Nom
lappend GscopeIdsOfIdAccProt(LISTOFIDACCPROTS) $IapLu
}
}
set GscopeIdsOfIdAccProt(LISTOFIDACCPROTS) [lsort -unique $GscopeIdsOfIdAccProt(LISTOFIDACCPROTS)]
return [GscopeIdsOfIdAccProt $Iap]
}
proc GscopeIdsOfIdAccArnm {accarnm} {
global GscopeIdsOfIdAccArnm
if {[info exists GscopeIdsOfIdAccArnm($accarnm)]} { return $GscopeIdsOfIdAccArnm($accarnm) }
if {[info exists GscopeIdsOfIdAccArnm("EstCharge")]} { return {} }
set GscopeIdsOfIdAccArnm("EstCharge") 1
foreach Nom [ListeDesPABs] {
set Acc [AccessEvi $Nom]
lappend GscopeIdsOfIdAccArnm($Acc) $Nom
}
return [GscopeIdsOfIdAccArnm $accarnm]
}
proc DefinitionsOfAliasGeneName Gn {
set DefinitionsOfAliasGeneName {}
foreach Nom [GscopeIdsOfGeneName $Gn] {
lappend DefinitionsOfAliasGeneName "$Nom [ValiGN $Nom] [DefinitionRapide $Nom]"
}
return $DefinitionsOfAliasGeneName
}
proc GscopeIdsOfProbeSet {Ps} {
global GscopeIdsOfProbeSet
if {[info exists GscopeIdsOfProbeSet($Ps)]} { return $GscopeIdsOfProbeSet($Ps) }
if {[info exists GscopeIdsOfProbeSet("EstCharge")]} { return {} }
set GscopeIdsOfProbeSet("EstCharge") 1
foreach Nom [ListeDesPABs] {
set LaLigneProbesSet [ExtraitInfo $Nom "ProbeSetId:"]
regsub -all "/" $LaLigneProbesSet "-OU-" LaLigneProbesSet
set LesProbesSet [split $LaLigneProbesSet ","]
foreach PsLu $LesProbesSet {
lappend GscopeIdsOfProbeSet($PsLu) $Nom
lappend GscopeIdsOfProbeSet(LISTOFProbeSet) $PsLu
}
}
return [GscopeIdsOfProbeSet $Ps]
}
proc ProbesetsOfGscopeId Nom {
set PS [ExtraitInfo $Nom "ProbesetId"]
if {[regexp -nocase "no value" $PS]} { return {} }
set LesPS [split $PS ", "]
return $LesPS
}
proc ProbesetsOfGeneName {Gn} {
set LesProbesetsOfGeneName {}
foreach Nom [GscopeIdsOfGeneName $Gn] {
LConcat LesProbesetsOfGeneName [ProbesetsOfGscopeId $Nom]
}
return [lsort -unique $LesProbesetsOfGeneName]
}
proc GscopeIdsOfGeneName {Gn {WithSynonyms ""}} {
global GscopeIdsOfGeneName
set WithSynonyms [regexp -nocase "WithSynonym" $WithSynonyms]
set GN [string toupper $Gn]
if {[info exists GscopeIdsOfGeneName($GN)]} { return $GscopeIdsOfGeneName($GN) }
if {[info exists GscopeIdsOfGeneName("EstCharge")]} { return {} }
set GscopeIdsOfGeneName("EstCharge") 1
set GscopeIdsOfGeneName(LISTOFGENENAMES) {}
foreach Nom [ListeDesPABs] {
set ValiGN [ValiGN $Nom]
if {$ValiGN==""} {continue}
lappend GscopeIdsOfGeneName(LISTOFGENENAMES) $ValiGN
lappend GscopeIdsOfGeneName([string toupper $ValiGN]) $Nom
set LesAliasGn [AliasGeneNames $Nom]
foreach GnLu $LesAliasGn {
set GNLU [string toupper $GnLu]
lappend GscopeIdsOfGeneName($GNLU) $Nom
}
lappend GscopeIdsOfGeneName(LISTOFGENENAMES) $GnLu
if {$WithSynonyms} {
foreach Synonym [SynonymsOfGscopeId $Nom] {
set SYNONYM [string toupper $Synonym]
lappend GscopeIdsOfGeneName($SYNONYM) $Nom
}
}
}
set GscopeIdsOfGeneName(LISTOFGENENAMES) [lsort -unique $GscopeIdsOfGeneName(LISTOFGENENAMES)]
return [GscopeIdsOfGeneName $Gn]
}
proc AliasGeneNames Nom {
set LesGn {}
foreach PossibleAlias [list "AliasGnRna:" "AliasGnProt:" "AliasGnHuman:"] {
LConcat LesGn [split [ExtraitInfo $Nom $PossibleAlias] " "]
}
set LesAliasGn {}
set DejaVu([string toupper [ValiGN $Nom]]) 1
foreach Gn $LesGn {
set GN [string toupper $Gn]
if {[info exists DejaVu($GN)]} { continue }
set DejaVu($GN) $Gn
lappend LesAliasGn $Gn
}
return $LesAliasGn
}
proc CorrigeAliasGnEVImm {} {
foreach Nom [ListeDesPABs] {
Espionne $Nom
set F [GscopeFile $Nom "infos"]
if {[FileExists $F]} {
set LesLignes {}
foreach Ligne [LesLignesDuFichier $F] {
if {[regexp {^(AliasGnRna|AliasGnProt)} $Ligne]} {
regsub -all ", " $Ligne " " Ligne
regsub -all "," $Ligne " " Ligne
while {[regexp " " $Ligne]} { regsub -all " " $Ligne " " Ligne }
}
lappend LesLignes $Ligne
}
SauveLesLignes $LesLignes dans $F
}
set F [GscopeFile $Nom "infosfiche"]
if {[FileExists $F]} {
set LesLignes {}
foreach Ligne [LesLignesDuFichier $F] {
if {[regexp {^(RnaAliasGn|ProtAliasGn)} $Ligne]} {
regsub -all ", " $Ligne " " Ligne
regsub -all "," $Ligne " " Ligne
while {[regexp " " $Ligne]} { regsub -all " " $Ligne " " Ligne }
}
lappend LesLignes $Ligne
}
SauveLesLignes $LesLignes dans $F
}
}
}
proc TranscriptomicSignalIntensity Nom {
set Rep "[RepertoireDuGenome]/transcriptomique/SignalIntensity"
set LesFichiers [glob -nocomplain "$Rep/$Nom-*"]
set LaSortie {}
foreach Fichier $LesFichiers {
set Queue [file tail $Fichier]
set Probeset [StringSuivant "-" dans $Queue]
lappend LaSortie ""
lappend LaSortie "$Nom $Probeset"
foreach Ligne [LesLignesDuFichier $Fichier] {
ScanLaListe [split $Ligne "\t"] Ps Ch Ex Sa Si Ca Re So
lappend LaSortie "$Ps [format "%6.2f" $Si] [format "%1s" $Ca] $Re [format "%-8s" $So] $Ch $Ex $Sa"
}
}
set Texte [join $LaSortie "\n"]
if {[PourWscope]} { return [Html_DuTexteTelQuel $Texte] }
return $Texte
}
proc InterrogeCopainsDesCompulsory {{Qui ""} {Quoi ""}} {
global InterrogeCopainsDesCompulsory
if {$Quoi==""} {set Quoi "Nom"}
if {[info exists InterrogeCopainsDesCompulsory($Qui,$Quoi)]} {
#if {[PourWscope]} {return "[join $InterrogeCopainsDesCompulsory($Qui,$Quoi) "\n"]
"}
return $InterrogeCopainsDesCompulsory($Qui,$Quoi)
}
if {[info exists InterrogeCopainsDesCompulsory("EstCharge")]} { return "" }
set InterrogeCopainsDesCompulsory("EstCharge") 1
#attention certains n'ont pas gn
set Repertoire "[RepertoireDuGenome]/transcriptomique/LesCopainsClusterSsBigClu"
set Seuil 8
set I 0
foreach Nom [ListOfCompulsoryGenes] {
set LesGnsDuNom {}
#Espionne "$Nom"
set InterrogeCopainsDesCompulsory($Nom,Boite) {}
foreach File [glob -nocomplain "$Repertoire/${Nom}-*-lesbestcops"] {
#Espionne "File $File"
if {[regexp "AFFX" $File]} {Espionne "Attention AFFX"}
set premiereligne 1
foreach Ligne [LesLignesDuFichier $File] {
if {$premiereligne} {
set premiereligne 0
scan $Ligne "%s %s" nbdecombinaisoncompul bidon
set TabCompul($Nom) $nbdecombinaisoncompul
}
set LesMots [split $Ligne " "]
set nb [lindex $LesMots 0]
if {$nb < $Seuil} {continue}
#Espionne "nb $nb"
set EviPs [lindex $LesMots 1]
if {[regexp "AFFX" EviPs]} {Espionne "Attention2"}
set LesEviPs [split $EviPs "-"]
set Boite [lindex $LesEviPs 0]
set Gn [lindex $LesMots 2]
lappend InterrogeCopainsDesCompulsory($Nom,Boite) $Boite
lappend InterrogeCopainsDesCompulsory($Boite,Nom) $Nom
set InterrogeCopainsDesCompulsory($Boite,Nom) [lsort -unique $InterrogeCopainsDesCompulsory($Boite,Nom)]
#Espionne "$Boite $Gn"
}
}
set InterrogeCopainsDesCompulsory($Nom,Boite) [lsort -unique $InterrogeCopainsDesCompulsory($Nom,Boite)]
}
return [InterrogeCopainsDesCompulsory $Qui $Quoi]
}
proc BelleVue {H V Nom} {
if {$H=="ProbeSetId" || $H=="ProbeSet"} {return [H_Href $V "http://genoret.igbmc.fr/genoret/Project/igbmc/evimm/testGscopeLaetitia.php?GscopeID=$Nom" "target='_blank'"]}
#if {$H=="ProbeSetId"} {return [H_Href $V "[LbgiUrl]/SignalIntensityImage/$Nom*" "target='_blank'"]}
if {$H=="GscopeId"} {return [H_Href $V "[WscopeScience]&FileMoi&$Nom" "target='_blank'"]}
if {$H=="Description"} {return [H_Href $V "[WscopeScience]&FileMoi¬es&$Nom" "target='_blank'"]}
if {$H=="TissueTypes" || $H=="TissueType"} {
return [H_Href $V "[LbgiUrl]/jpg_of_TissType/${Nom}_TissType.jpg" "target='_blank'"]
}
if {$H=="DevStages"} {
return [H_Href $V "[LbgiUrl]/jpg_of_DevStage/${Nom}_DevStage.jpg" "target='_blank'"]
}
if {$H=="AccessmRNA"} {
return [H_Href $V [WgetzSurWeb "$V" "" "GetUrl"] "target='_blank'"]
}
if {$H=="AccessProt"} {
return [H_Href $V [WgetzSurWeb "$V" "" "GetUrl"] "target='_blank'"]
}
if {$H=="CopainsDesCompulsory"} {
return [H_Href $V "[WscopeScience]&InterrogeCopainsDesCompulsory&$Nom" "target='_blank'"]
}
if {$H=="cDNA"} {
return [H_Href $V "[WscopeScience]&FileMoi&ResultcDNA/RecapInfoADNc&$Nom" "target='_blank'"]
}
return $V
}
proc RetinalGenesSummaryOnWeb {{ListeDesNoms ""} {TitreSummary ""} args} {
set LesHeadSup {}
set I 0
foreach {PH LesV} $args {
regsub "_" $PH " " PH
scan $PH "%s %s" Pos Head
incr Pos $I
lappend LesHeadSup $Head
set PosSup($Head) $Pos
set K 0
foreach V $LesV {
set ValSup($Head,$K) $V
incr K
}
incr I
}
set LesHeaders [RecapitulatifRetChip "LesHeaders" "GetIt"]
foreach Head $LesHeadSup {
set LesHeaders [linsert $LesHeaders $PosSup($Head) $Head]
}
set NbHeaders [llength $LesHeaders]
set Titre "Gscope summary for Retinal Genes $TitreSummary"
set HeaderDuHtml ""
Html_ZeroToBody $Titre $HeaderDuHtml
Html_BackTo
Html_Append [H_Balise $Titre "h3"]
set NbCol $NbHeaders
CouleurDegradee $NbCol
set Liste {}
lappend Liste $NbCol
lappend Liste "border='1' cellpadding='3' cellspacing='1'"
lappend Liste ""
foreach Header $LesHeaders {
lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
}
foreach Header $LesHeaders {
lappend Liste $Header
}
set K 0
foreach Ligne [RecapitulatifRetChip $ListeDesNoms "GetIt"] {
Espionne "Debut$Ligne FIN"
set LesValeurs [split $Ligne ";"]
foreach Head $LesHeadSup {
set P $PosSup($Head)
set V ""
if {[info exists ValSup($Head,$K)]} { set V $ValSup($Head,$K) }
set LesValeurs [linsert $LesValeurs $P $V]
}
incr I
set Nom [lindex $LesValeurs 0]
if { ! [EstUnPAB $Nom]} { continue }
foreach H $LesHeaders V $LesValeurs {
set Vue [BelleVue $H $V $Nom]
lappend Liste $Vue
}
incr K
}
Html_TableFromList $Liste
Html_BodyToEnd
return [Html_Get "ZeroIt"]
}
proc RetinalGenesForSelectionOnWeb {{ListeDesNoms ""} {TitreSummary ""} args} {
set LesHeadSup {}
set I 0
foreach {PH LesV} $args {
regsub "_" $PH " " PH
scan $PH "%s %s" Pos Head
incr Pos $I
lappend LesHeadSup $Head
set PosSup($Head) $Pos
set K 0
foreach V $LesV {
set ValSup($Head,$K) $V
incr K
}
incr I
}
set Fichier "[RepertoireDuGenome]/Reduction/TableauPourReductionSsRedondanceTrie"
set LesLignes [LesLignesDuFichier $Fichier]
set LigneDeTete [lindex $LesLignes 0]
set LesHeaders [split $LigneDeTete ";"]
#set LesHeaders [RecapitulatifRetChip "LesHeaders" "GetIt"]
foreach Head $LesHeadSup {
set LesHeaders [linsert $LesHeaders $PosSup($Head) $Head]
}
set NbHeaders [llength $LesHeaders]
set Titre "Selection of Retinal Genes $TitreSummary"
set HeaderDuHtml ""
Html_ZeroToBody $Titre $HeaderDuHtml
Html_BackTo
Html_Append [H_Balise $Titre "h3"]
set NbCol $NbHeaders
CouleurDegradee $NbCol
set Liste {}
lappend Liste $NbCol
lappend Liste "border='1' cellpadding='3' cellspacing='1'"
lappend Liste ""
foreach Header $LesHeaders {
lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
}
foreach Header $LesHeaders {
lappend Liste $Header
}
set K 0
foreach Ligne $LesLignes {
#foreach Ligne [RecapitulatifRetChip $ListeDesNoms "GetIt"]
Espionne "Debut$Ligne FIN"
set LesValeurs [split $Ligne ";"]
foreach Head $LesHeadSup {
set P $PosSup($Head)
set V ""
if {[info exists ValSup($Head,$K)]} { set V $ValSup($Head,$K) }
set LesValeurs [linsert $LesValeurs $P $V]
}
incr I
set Nom [lindex $LesValeurs 0]
if { ! [EstUnPAB $Nom]} { continue }
foreach H $LesHeaders V $LesValeurs {
set Vue [BelleVue $H $V $Nom]
#set LongV [string length $V]
#if {$LongV>=80}
#set Milieu [expr $LongV / 2]
#set Vue "[string range $Vue 0 $Milieu]
[string range $Vue [expr $Milieu+1] end]"
lappend Liste $Vue
}
incr K
}
Html_TableFromList $Liste
Html_BodyToEnd
return [Html_Get "ZeroIt"]
}
proc ImAnnoRefPour Nom {
global ListOfRetChipAnnotated
set UrlGenoretServer [GenoretServer]
if { ! [info exists ListOfRetChipAnnotated]} {
set ListOfRetChipAnnotated [HttpGetUrl "$UrlGenoretServer?Genoret&ListOfRetChipAnnotated"]
}
set R ""
foreach Syno [RecupereSynonyms $Nom "AvecGN" " "] {
if {[lsearch $ListOfRetChipAnnotated $Syno] >= 0} { set R $Syno ; break }
}
if {$R ne ""} {
set Ref "$R"
} else {
set Ref "-"
}
return $Ref
}
proc RetChipGenesOnWeb {{ListeDesNoms ""} {TitreSummary ""} args} {
set LesHeadSup {}
set I 0
foreach {PH LesV} $args {
regsub "_" $PH " " PH
scan $PH "%s %s" Pos Head
incr Pos $I
lappend LesHeadSup $Head
set PosSup($Head) $Pos
set K 0
if {[regexp "^Generic_" $LesV]} {
set VG $LesV
regsub "^Generic_" $VG "" VG
regsub -all "_" $VG " " VG
set ValeurGenerique($Head) $VG
} else {
foreach V $LesV {
set ValSup($Head,$K) $V
incr K
}
}
incr I
}
set FichierComp "[RepertoireDuGenome]/Reduction/TableauDesCompulsory"
set Fichier78 "[RepertoireDuGenome]/Reduction/TableauDes7et8"
set FichierParal "[RepertoireDuGenome]/Reduction/TableauDesParalogue"
set Fichier7 "[RepertoireDuGenome]/Reduction/TableauDes7"
set LesLignesComp [LesLignesDuFichier $FichierComp]
set LesLignes78 [LesLignesDuFichier $Fichier78]
set LesLignesParal [LesLignesDuFichier $FichierParal]
set LesLignes7 [LesLignesDuFichier $Fichier7]
set LigneDeTete [lindex $LesLignesComp 0]
set LesHeaders [split $LigneDeTete ";"]
foreach Head $LesHeadSup {
set LesHeaders [linsert $LesHeaders $PosSup($Head) $Head]
}
set NbHeaders [llength $LesHeaders]
set Titre "1500 RetChip Genes $TitreSummary"
set HeaderDuHtml ""
Html_ZeroToBody $Titre $HeaderDuHtml
Html_BackTo
Html_Append [H_Balise $Titre "h2"]
foreach L [list $LesLignesComp $LesLignes78 $LesLignes7] \
T [list "Compulsory Genes" "+7+8 Genes" "+7-8 Genes"] {
Html_Append [H_Balise $T "h3"]
set NbCol $NbHeaders
CouleurDegradee $NbCol
set Liste {}
lappend Liste $NbCol
lappend Liste "border='1' cellpadding='3' cellspacing='1'"
lappend Liste ""
foreach Header $LesHeaders {
lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
}
foreach Header $LesHeaders {
lappend Liste $Header
}
set K 0
foreach Ligne $L {
Espionne "Debut$Ligne FIN"
set LesValeurs [split $Ligne ";"]
incr I
set Nom [lindex $LesValeurs 0]
foreach Head $LesHeadSup {
set P $PosSup($Head)
set V ""
if {[info exists ValSup($Head,$K)]} { set V $ValSup($Head,$K) }
if {[info exists ValeurGenerique($Head)]} {
regsub -all "XXXX" $ValeurGenerique($Head) $Nom V
set V [eval $V]
}
set LesValeurs [linsert $LesValeurs $P $V]
}
if { ! [EstUnPAB $Nom]} { continue }
foreach H $LesHeaders V $LesValeurs {
if {$H=="ProbeSet" || $H=="Pathway"} {
set LongV [string length $V]
if {$LongV>=200} {
set Milieu [expr $LongV / 2]
set V "[string range $V 0 $Milieu]
[string range $V [expr $Milieu+1] end]"
}
}
set Vue [BelleVue $H $V $Nom]
lappend Liste $Vue
}
incr K
}
Html_TableFromList $Liste
}
Html_BodyToEnd
return [Html_Get "ZeroIt"]
#rR suite obsolete
Html_Append [H_Balise "Compulsory Genes" "h3"]
set NbCol $NbHeaders
CouleurDegradee $NbCol
set Liste {}
lappend Liste $NbCol
lappend Liste "border='1' cellpadding='3' cellspacing='1'"
lappend Liste ""
foreach Header $LesHeaders {
lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
}
foreach Header $LesHeaders {
lappend Liste $Header
}
set K 0
foreach Ligne $LesLignesComp {
Espionne "Debut$Ligne FIN"
set LesValeurs [split $Ligne ";"]
foreach Head $LesHeadSup {
set P $PosSup($Head)
set V ""
if {[info exists ValSup($Head,$K)]} { set V $ValSup($Head,$K) }
set LesValeurs [linsert $LesValeurs $P $V]
}
incr I
set Nom [lindex $LesValeurs 0]
if { ! [EstUnPAB $Nom]} { continue }
foreach H $LesHeaders V $LesValeurs {
if {$H=="ProbeSet" || $H=="Pathway"} {
set LongV [string length $V]
if {$LongV>=200} {
set Milieu [expr $LongV / 2]
set V "[string range $V 0 $Milieu]
[string range $V [expr $Milieu+1] end]"
}
}
set Vue [BelleVue $H $V $Nom]
lappend Liste $Vue
}
incr K
}
Html_TableFromList $Liste
Html_Append [H_Balise "+7+8 Genes" "h3"]
set NbCol $NbHeaders
CouleurDegradee $NbCol
set Liste {}
lappend Liste $NbCol
lappend Liste "border='1' cellpadding='3' cellspacing='1'"
lappend Liste ""
foreach Header $LesHeaders {
lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
}
foreach Header $LesHeaders {
lappend Liste $Header
}
set K 0
foreach Ligne $LesLignes78 {
Espionne "Debut$Ligne FIN"
set LesValeurs [split $Ligne ";"]
foreach Head $LesHeadSup {
set P $PosSup($Head)
set V ""
if {[info exists ValSup($Head,$K)]} { set V $ValSup($Head,$K) }
set LesValeurs [linsert $LesValeurs $P $V]
}
incr I
set Nom [lindex $LesValeurs 0]
if { ! [EstUnPAB $Nom]} { continue }
foreach H $LesHeaders V $LesValeurs {
set Vue [BelleVue $H $V $Nom]
lappend Liste $Vue
}
incr K
}
Html_TableFromList $Liste
#Html_Append [H_Balise "removed paralogues" "h3"]
#set NbCol $NbHeaders
#CouleurDegradee $NbCol
#set Liste {}
#lappend Liste $NbCol
#lappend Liste "border='1' cellpadding='3' cellspacing='1'"
#lappend Liste ""
#foreach Header $LesHeaders {
# lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
# }
# foreach Header $LesHeaders {
#lappend Liste $Header
#}
#set K 0
#foreach Ligne $LesLignesParal {
#Espionne "Debut$Ligne FIN"
#set LesValeurs [split $Ligne ";"]
#foreach Head $LesHeadSup {
# set P $PosSup($Head)
# set V ""
# if {[info exists ValSup($Head,$K)]} { set V $ValSup($Head,$K) }
# set LesValeurs [linsert $LesValeurs $P $V]
# }
#incr I
#set Nom [lindex $LesValeurs 0]
#if { ! [EstUnPAB $Nom]} { continue }
#foreach H $LesHeaders V $LesValeurs {
# set Vue [BelleVue $H $V $Nom]
# lappend Liste $Vue
#}
#incr K
#}
#Html_TableFromList $Liste
Html_Append [H_Balise "+7-8 Genes" "h3"]
set NbCol $NbHeaders
CouleurDegradee $NbCol
set Liste {}
lappend Liste $NbCol
lappend Liste "border='1' cellpadding='3' cellspacing='1'"
lappend Liste ""
foreach Header $LesHeaders {
lappend Liste "bgcolor='[CouleurDegradee]' nowrap='nowrap'"
}
foreach Header $LesHeaders {
lappend Liste $Header
}
set K 0
foreach Ligne $LesLignes7 {
Espionne "Debut$Ligne FIN"
set LesValeurs [split $Ligne ";"]
foreach Head $LesHeadSup {
set P $PosSup($Head)
set V ""
if {[info exists ValSup($Head,$K)]} { set V $ValSup($Head,$K) }
set LesValeurs [linsert $LesValeurs $P $V]
}
incr I
set Nom [lindex $LesValeurs 0]
if { ! [EstUnPAB $Nom]} { continue }
foreach H $LesHeaders V $LesValeurs {
set Vue [BelleVue $H $V $Nom]
lappend Liste $Vue
}
incr K
}
Html_TableFromList $Liste
Html_BodyToEnd
return [Html_Get "ZeroIt"]
}
proc EviSummary {{GN ""}} {
set LesLignes {}
foreach Nom [ListeDesPABs] {
if { ! [regexp -nocase $GN [ExtraitInfo $Nom "ValiGN"]]} { continue }
set DE [ExtraitInfo $Nom "ValiDE"]
set OS [ExtraitInfo $Nom "Organism"]
set Ligne "$Nom;$GN;$OS;$DE"
lappend LesLignes $Ligne
}
return [join $LesLignes "\n"]
}
proc CorrigeInfosEVI {} {
foreach Nom [ListeDesPABs] {
set DE [ExtraitInfo $Nom "DE"]
if {$DE!=""} {
InformeParSuppressionDuChamp $Nom "DE:"
InformeSansDemander $Nom "ValiDE: $DE"
}#rR Debut de gscope_atelier.tcl
set GN [ExtraitInfo $Nom "ValiGN"]
if {[regexp -nocase (Fragment|Mouse) $GN]} {
InformeParSuppressionDuChamp $Nom "ValiGN:"
Espionne $GN
}
}
}
proc ShowDuplicates {} {
foreach GN [RetinalGene] {
if {[llength [set LesNoms [RetinalGene GscopeIdOf $GN]]]<2} { continue }
Espionne "$GN $LesNoms"
}
}
proc RetinalGene {{Qui ""} {Quoi ""}} {
global RetinalGene
if {$Qui==""} {
set Qui "ListAll"
set Quoi "GN"
}
if {[regexp -nocase {^Genes?$} $Quoi]} { set Quoi "GN" }
if {[info exists RetinalGene($Qui,$Quoi)]} { return $RetinalGene($Qui,$Quoi)}
if {$Qui=="GscopeIdsOf"} {
if {[info exists RetinalGene(GscopeIdsOfUppercase,[string toupper $Quoi])]} {
return $RetinalGene($Qui,$Quoi)
}
}
if {[info exists RetinalGene("EstCharge")]} { return ""}
set RetinalGene(ListAll,GN) {}
foreach Nom [ListeDesPABs] {
set GN [ExtraitInfo $Nom "ValiGN"]
if {$GN==""} { continue }
set RetinalGene(GeneNameOf,$Nom) $GN
lappend RetinalGene(GscopeIdsOf,$GN) $Nom
lappend RetinalGene(GscopeIdsOfUppercase,[string toupper $GN]) $Nom
lappend RetinalGene(ListAll,GN) $GN
}
set RetinalGene(ListAll,GN) [lsort -u $RetinalGene(ListAll,GN)]
foreach GN $RetinalGene(ListAll,GN) {
foreach Nom $RetinalGene(GscopeIdsOf,$GN) {
lappend RetinalGene(ListAll,GscopeIds) $Nom
}
}
set RetinalGene("EstCharge") 1
return [RetinalGene $Qui $Quoi]
}
proc InformeRetinalTargets {} {
foreach Nom [ListeDesPABs] {
set Entete [EnteteDuFichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"]
if {[regexp "bidon" $Entete]} {
set Raison [StringSuivant "bidon" dans $Entete]
InformeSansDemander $Nom "SeqWarning: No sequence available $Raison"
continue
}
set iP [string last "(" $Entete]
set GN ""
if {$iP>0} {
set iF [string last ")" $Entete]
set GN [string range $Entete [incr iP] [incr iF -1]]
if {[regexp " " $GN]} { set GN "" }
if {[regexp -nocase "Fragment" $GN]} { set GN "" }
}
if {$GN!=""} { InformeSansDemander $Nom "ValiGN: $GN" }
scan $Entete "%s %s %s %s" N BId Genre Espece
if {$Genre=="M."} { set Genre "Mus" }
InformeSansDemander $Nom "Organism: $Genre $Espece"
InformeSansDemander $Nom "BId: $BId"
set DE [StringSuivant " " dans $Entete]
if {$DE!=""} { InformeSansDemander $Nom "DE: $DE" }
}
exit
}
proc CreateRetinalTargets {} {
set D 1000
set PremiereFois 1
foreach Ligne [LesLignesDuFichier "/genomics/link/EVItest/parser/AttriToutVf"] {
if {[regexp "^ligne" $Ligne]} {
set YaEuLigne 1
set NumLigne [IntegerApres "ligne" dans $Ligne]
set N [expr $NumLigne*10]
continue
}
if { ! [regexp "^>" $Ligne]} {
lappend LeTFA $Ligne
continue
}
if { ! $PremiereFois} {
Espionne "Sauve dans $Nom"
SauveLesLignes $LeTFA dans "/genomics/link/EVItest/nuctfa/$Nom"
}
regsub ">" $Ligne "" Ligne
if {[regexp "bidon" $Ligne] && ! $YaEuLigne} { FaireLire "Un bidon sans ligne !!!"}
set YaEuLigne 0
set I 0
while 1 {
set Nom [format "EVI%5.5d" [expr $N+$I]]
if { ! [info exists DejaVu($Nom)]} { break }
incr I
}
set DejaVu($Nom) 1
set F [expr $D + 3000]
set Bornes "$Nom $D $F F"
incr D 3300
lappend LesBornes $Bornes
if {[regexp "^bidon" $Ligne]} {
regsub -all {\'} $Ligne " " Ligne
set L ">$Nom $Ligne"
} else {
ScanLaListe [split $Ligne "|"] B A A2
set Entete [StringSuivant " " dans $Ligne]
regsub "genbankfull" $B "gbf" B
regsub "refseqnew" $B "rsn" B
regsub "refseqrelease" $B "rsr" B
regsub "refseq" $B "rs" B
set L ">$Nom $B:$A $Entete"
}
Espionne "\n$L"
set LeTFA [list $L]
set PremiereFois 0
continue
}
SauveLesLignes $LeTFA dans "/genomics/link/EVItest/nuctfa/$Nom"
SauveLesLignes $LesBornes dans "/genomics/link/EVItest/fiches/bornesdespabs"
exit
}
proc AcDuId {ID {Fichier ""}} {
global AcDuId
if {$Fichier==""} { set Fichier "[Fiches]/IDAC.txt" }
if {[info exists AcDuId($ID)]} { return $AcDuId($ID) }
if {[info exists AcDuId("EstCharge")]} { return "" }
set AcDuId("EstCharge") 1
foreach {N I A B} [LesLignesDuFichier $Fichier] {
scan $N "%s %s" Bidon Nom
if {[regexp "_" $Nom]} { continue }
scan $I "%s %s" Bidon Id
scan $A "%s %s" Bidon Ac
regsub {\;} $Ac "" Ac
set AcDuId($Id) $Ac
}
return [AcDuId $ID]
}
proc IndexDuDescrCustom {OldNew Valeur} {
global IndexDuDescrCustom
if {[info exists IndexDuDescrCustom($OldNew,$Valeur)]} { return $IndexDuDescrCustom($OldNew,$Valeur) }
if {[info exists IndexDuDescrCustom("EstCharge")]} { return "" }
set IndexDuDescrCustom("EstCharge") 1
foreach IndexA [RetChip2 ListOf Index] {
set VA [RetChip2 $IndexA "description_customer"]
lappend IndexDuDescrCustom(Ancien,$VA) $IndexA
}
foreach IndexB [RetChip3 ListOf Index] {
set VB [RetChip3 $IndexB "description_customer"]
lappend IndexDuDescrCustom(Nouveau,$VB) $IndexB
}
return [IndexDuDescrCustom $OldNew $Valeur]
}
proc MonCopain {Quoi Moi} {
global MonCopain
if {[info exists MonCopain($Quoi,$Moi)]} {return $MonCopain($Quoi,$Moi)}
if {[info exists MonCopain("EstCharge")]} {return ""}
set MonCopain("EstCharge") 1
set LesAnciensHeader [RetChip2 ListOf Header]
set LesAnciensIndex [RetChip2 ListOf Index]
set LesNouveauxIndex [RetChip3 ListOf Index]
set LongA [llength $LesAnciensIndex]
set LongB [llength $LesNouveauxIndex]
set A 0
set B 0
set Decal 0
while 1 {
if {$A>=$LongA} { break }
set IndexA [lindex $LesAnciensIndex $A]
set IndexB [lindex $LesNouveauxIndex $B]
set Ok 1
foreach H $LesAnciensHeader {
if {$H=="status_ID"} { continue }
set VA [RetChip2 $IndexA $H]
set VB [RetChip3 $IndexB $H]
if {$VA=="" || $VB==""} { continue }
if {[RetChip2 $IndexA $H]!=[RetChip3 $IndexB $H]} {
if {[regexp -nocase {[a-z]} $VA] && [regexp {\,} $VB] && [regexp $VA $VB]} { break }
set Ok 0
}
break
}
if {$Ok} {
set MonCopain(Nouveau,$IndexA) $IndexB
set MonCopain(Ancien,$IndexB) $IndexA
set LastNotYetAffected ""
incr A
incr B
set Decal 0
set RepereA $A
set RepereB $B
continue
}
# Espionne "$IndexA $IndexB\n[RetChip2 $IndexA WholeLine]\n[RetChip3 $IndexB WholeLine]"
set MonCopain(Ancien,$IndexB) "NouveauAvant $IndexA"
set LastNotYetAffected $IndexA
incr B
if {$B>=$LongB || [incr Decal]>100} {
set Decal 0
set A [incr RepereA]
set B $RepereB
}
}
if {$LastNotYetAffected!=""} { FaireLire "Horreur ! $IndexA n'a pas de nouveau copain\nVoir $MonCopain(Nouveau,[expr $IndexA -1])" }
return [MonCopain $Quoi $Moi]
}
proc TestMonCopain {} {
foreach IndexA [RetChip2 ListOf Index] {
if {[set IndexB [MonCopain Nouveau $IndexA]]==""} {
Espionne "$IndexA [RetChip2 $IndexA description_customer]"
continue
}
set VA [RetChip2 $IndexA WholeLine]
set VB [RetChip3 $IndexB WholeLine]
set LesMots [split $VB ";"]
set LesMots [concat [lrange $LesMots 0 6] [list ""] [lrange $LesMots 8 end]]
set VB [join $LesMots ";"]
if {[string first $VA $VB]==0} { continue }
Espionne "$IndexA $IndexB\n$VA\n$VB\n"
}
exit
}
proc AvecKegg Nom {
global AvecKegg
if {[info exists AvecKegg($Nom)]} { return $AvecKegg($Nom) }
if {[info exists AvecKegg("EstCharge")]} { return "NotAvailable" }
set AvecKegg("EstCharge") 1
set FK [Fiches "Kegg"]
if {[FileAbsent $FK]} { return 0 }
foreach Ligne [LesLignesDuFichier $FK] {
set NomLu ""
scan $Ligne "%s" NomLu
if {[regexp "Nothing" $Ligne]} {
set AvecKegg($NomLu) "Nothing"
} else {
set AvecKegg($NomLu) "Yes"
}
}
return [AvecKegg $Nom]
}
proc MultipleProbeset {} {
foreach P [AffyAnno ListOf Index] {
set GeneChipArray [AffyAnno $P "GeneChip_Array"]
if {[regexp { \-or\- } $GeneChipArray]} {
Espionne "$P $GeneChipArray"
}
}
}
proc MeilleurEMBL Nom {
set onaswiss 0
Espionne "coucoucA"
array set TabCorres [LesLignesDuFichier "[RepertoireDuGenome]/fiches/TabCorres"]
Espionne "coucoucB"
set Racine [GscopeFile $Nom "protembl"]
set LesPossibles [lsort [glob -nocomplain ${Racine}_*]]
if {$LesPossibles=={}} { return "" }
set LesInfos {}
foreach Fichier $LesPossibles {
set Queue [file tail $Fichier]
set LigneDT ""
set Fragment 0
set Date "01-JAN-1970"
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp "^SQ " $Ligne]} { break }
if {[regexp "^DT " $Ligne]} { set LigneDT $Ligne }
if {[regexp "^DE " $Ligne]} {
if {[regexp -nocase "\(Fragment\)" $Ligne]} { set Fragment 1 }
}
}
scan $LigneDT "%s %s" Bidon Date
set Banque $TabCorres($Queue)
lappend LesInfos "$Date $Fragment $Queue $Banque"
}
set LesInfosTriees [lsort -decreasing -index 0 -command "CompareDate" $LesInfos]
#EspionneL $LesInfosTriees
foreach elmt [array names TabCorres] {
if {[regexp "^$Nom" $elmt]} {
if {[regexp "SWISSPROT" $TabCorres($elmt)]} {
set onaswiss 1
}
}
}
foreach Info $LesInfosTriees {
scan $Info "%s %s %s %s" D F Q B
if {$F} { continue }
if {$onaswiss && [regexp "SPTREMBL" $B]} {continue}
return $Q
}
scan [lindex $LesInfosTriees 0] "%s %s %s %s" D F Q B
return $Q
}
proc DeProtEmblVersProtTfaEvi {{Liste ""}} {
if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
if {$Liste==""} { set Liste [ListeDesPABs] }
set RepProtInter "[RepertoireDuGenome]/protintermediare"
if { ! [file exists $RepProtInter]} { File mkdir $RepProtInter }
foreach Nom $Liste {
Espionne "coucouc"
set FichierProtEmbl "[GscopeFile $Nom protembl]"
if {[FileExists $FichierProtEmbl]} { continue }
set FichierProtTfa "[GscopeFile $Nom protintermediare/prottfaBEST]"
set FichierProtTfa2 "[GscopeFile $Nom protintermediare/prottfaBEST2]"
if {[FileExists $FichierProtTfa] || [FileExists $FichierProtTfa2]} { continue }
set FichierProtEmbldeux ""; set FichierProtEmblun ""
set FichierProtEmblun "[GscopeFile $Nom protembl]_1"
set FichierProtEmbldeux "[GscopeFile $Nom protembl]_2"
if {![file exists $FichierProtEmblun]} {continue}
if {[file exists $FichierProtEmbldeux]} {
set Repprottfabest2 "$RepProtInter/prottfaBEST2"
Espionne "coucouc2"
if { ! [file exists $Repprottfabest2]} { File mkdir $Repprottfabest2 }
DeProtEmblMultipleVersProtTfaEvi $Nom
} else {
set Repprottfabest "$RepProtInter/prottfaBEST"
if { ! [file exists $Repprottfabest]} { File mkdir $Repprottfabest }
DeProtEmblSingleVersProtTfaEvi $Nom
}
}
}
proc DeProtEmblSingleVersProtTfaEvi {Nom} {
set FichierProtEmblun "[GscopeFile $Nom protembl]_1"
set FichierProtEmbl "[GscopeFile $Nom protembl]"
set FichierProtTfa "[GscopeFile $Nom protintermediare/prottfaBEST]"
file copy -force $FichierProtEmblun $FichierProtEmbl
set LesLignesEMBL [LesLignesDuFichier $FichierProtEmbl]
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceBrute
set EnteteProtTfa "$Nom $AC from $ID $OS $DE"
set ProtTfa [SequenceFormatTFA [ContenuDuFichier $FichierProtEmbl] "ForceHeaderTo=$EnteteProtTfa" "embl"]
Sauve $ProtTfa dans $FichierProtTfa
}
proc DeProtEmblMultipleVersProtTfaEvi {Nom} {
set FichierProtEmbl "[GscopeFile $Nom protembl]"
set FichierProtTfa2 "[GscopeFile $Nom protintermediare/prottfaBEST2]"
Espionne "couocu3"
set Meilleur [MeilleurEMBL $Nom]
Espionne "coucou4"
if {$Meilleur==""} { continue }
regsub $Nom $FichierProtEmbl $Meilleur FichierProtEmblMeilleur
file copy $FichierProtEmblMeilleur $FichierProtEmbl
set LesLignesEMBL [LesLignesDuFichier $FichierProtEmbl]
#Espionne $LesLignesEMBL
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceBrute
set EnteteProtTfa "$Nom $AC from $ID $OS $DE"
set ProtTfa [SequenceFormatTFA [ContenuDuFichier $FichierProtEmbl] "ForceHeaderTo=$EnteteProtTfa" "embl"]
Sauve $ProtTfa dans $FichierProtTfa2
}
proc RangeProt {Nom} {
set RepProtembl_ "[RepertoireDuGenome]/protintermediare/protembl_"
if { ! [file exists $RepProtembl_]} { File mkdir $RepProtembl_ }
foreach Fichier [glob -nocomplain "[RepertoireDuGenome]/protembl/$Nom*_*"] {
file rename -force $Fichier $RepProtembl_/.
}
set RepProttfa "[RepertoireDuGenome]/prottfa"
if { ! [file exists $RepProttfa]} { File mkdir $RepProttfa }
set Fichier "[RepertoireDuGenome]/protintermediare/prottfaBEST/$Nom"
set Fichier2 "[RepertoireDuGenome]/protintermediare/prottfaBEST2/$Nom"
if {[file exists $Fichier]} {
file copy -force $Fichier $RepProttfa/.
} else {
file copy -force $Fichier2 $RepProttfa/.
}
}
proc DeProtEmblRecupereVersProtTfaEvi {} {
set RepEntree "[RepertoireDuGenome]/protemblRecupere"
foreach FichierProtEmblRecupere [glob -nocomplain "$RepEntree/EVI*"] {
set Nom [file tail $FichierProtEmblRecupere]
#Espionne $Nom
set FichierProtTfa "[GscopeFile $Nom prottfaRecupere]"
set FichierNucTfa "[GscopeFile $Nom nuctfa]"
if {[FileExists $FichierProtTfa]} { continue }
set LesLignesEMBL [LesLignesDuFichier $FichierProtEmblRecupere]
#Espionne $LesLignesEMBL
if {[regexp {^LOCUS} [lindex $LesLignesEMBL 0]]} {
set TexteGB [ContenuDuFichier $FichierProtEmblRecupere]
set ProtTfa [SequenceFormatTFA $TexteGB "$Nom" "gbprot"]
#Espionne "$ProtTfa"
Sauve $ProtTfa dans $FichierProtTfa
continue
}
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceBrute
set EnteteProtTfa "$Nom $AC from $ID $OS $DE"
set ProtTfa [SequenceFormatTFA [ContenuDuFichier $FichierProtEmblRecupere] "ForceHeaderTo=$EnteteProtTfa" "embl"]
puts "$ProtTfa"
Sauve $ProtTfa dans $FichierProtTfa
}
}
proc essaidix {} {
set A 0; set B 0; set C 0; set D 0; set E 0; set G 0
foreach F [glob -nocomplain "[RepertoireDuGenome]/protemblRecupere/EVI*"] {incr A}
foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfaRecupere/EVI*"] {incr B}
foreach F [glob -nocomplain "[RepertoireDuGenome]/protembl/EVI*"] {incr C}
foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfaBEST/EVI*"] {incr D}
foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfaBEST2/EVI*"] {incr E}
foreach F [glob -nocomplain "[RepertoireDuGenome]/prottfa/EVI*"] {incr G}
puts "A= $A"; puts "B= $B"; puts "C= $C"; puts "D= $D"; puts "E= $E"; puts "G= $G"
}
proc essaivingt {{Liste ""}} {
set pls 0; set seul 0; set recupere 0
if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
if {$Liste==""} { set Liste [ListeDesPABs] }
foreach Nom $Liste {
set FichierProtEmblun "[GscopeFile $Nom protembl]_1"
set FichierProtEmbldeux "[GscopeFile $Nom protembl]_2"
set FichierProtEmblRecupere "[GscopeFile $Nom protemblRecupere]"
if {[file exists $FichierProtEmblun] && [file exists $FichierProtEmbldeux]} {incr pls}
if {[file exists $FichierProtEmblun] && ![file exists $FichierProtEmbldeux]} {incr seul}
if {[file exists $FichierProtEmblRecupere]} {incr recupere}
}
puts "pls $pls"
puts "seul $seul"
puts "recupere $recupere"
}
proc essai4994 {} {
set RepEntree "[RepertoireDuGenome]/protemblRecupere"
set FichierProtEmblRecupere "$RepEntree/EVI04994"
set Nom [file tail $FichierProtEmblRecupere]
puts $Nom
set FichierProtTfa "[GscopeFile $Nom prottfaRecupere]"
set FichierNucTfa "[GscopeFile $Nom nuctfa]"
if {[FileExists $FichierProtTfa]} { continue }
set LesLignesEMBL [LesLignesDuFichier $FichierProtEmblRecupere]
Espionne $LesLignesEMBL
}
proc ProtParGeneNamePourTous {{Liste ""}} {
if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
if {$Liste==""} { set Liste [ListeDesPABs] }
set Repprotembl "[RepertoireDuGenome]/protembl"
if { ! [file exists $Repprotembl]} { File mkdir $Repprotembl }
foreach Nom $Liste {
#Espionne $Nom
set Texte ""
set FichierProtembl "[GscopeFile $Nom protembl]_1"
if {[FileExists $FichierProtembl]} {continue}
set Acc [AccessEvi $Nom]
if {$Acc==""} { continue }
#Espionne "$Nom $Acc"
if {[regexp {^NM_} $Acc] || [regexp {^XM_} $Acc] || [regexp {^NR_} $Acc]} {
set Commande "getz \"\\\[refseq-acc:$Acc\\\] > \(\\\[swissprot-org:Mus musculus\\\] | \\\[sptrembl-org:Mus musculus\\\]\)\" \-vf acc"
set Texte [eval exec $Commande]
} else {
set Commande "getz \"\\\[genbankfull-acc:$Acc\\\] > \(\\\[swissprot-org:Mus musculus\\\] | \\\[sptrembl-org:Mus musculus\\\]\)\" \-vf acc"
set Texte [eval exec $Commande]
}
Espionne "$Texte"
if {$Texte==""} { continue }
set I 0
foreach BIdAcc [split $Texte "\n"] {
scan $BIdAcc "%s %s" BId Access
Espionne "BIdAcc $BIdAcc"
set LesLignesEMBL [LaSequenceDesBanques $BId $Access "OnVeutEMBL"]
if {$LesLignesEMBL == {}} { continue }
incr I
set FichierEMBL "[GscopeFile $Nom protembl]_$I"
set Queue [file tail $FichierEMBL]
set LesMots [split $BIdAcc ":"]
set Tab($Queue) [lindex $LesMots 0]
set F [SauveLesLignes $LesLignesEMBL dans $FichierEMBL]
#Espionne "$Nom $Acc [file tail $F]\n[join $LesLignesEMBL "\n"]"
}
}
set FichierTabCorres "[RepertoireDuGenome]/fiches/TabCorres"
AppendAuFichier $FichierTabCorres [join [array get Tab] "\n"]
#SauveLesLignes [array get Tab] dans TabCorres
#array set Tab [LesLignesDuFichier toto]
}
proc ProtParLocUcscPourTous {} {
foreach Nom [ListeDesPABs] {
Espionne [ProtParLocUcsc $Nom]
}
}
proc ProtParLocUcsc Nom {
set Acc [AccessEvi $Nom]
set ProtId [LocUcsc $Acc proteinID]
if {$ProtId==""} { return "" }
set LesLignesEmbl [LaSequenceDesBanques $ProtId]
return [SauveLesLignes $LesLignesEmbl dans "[RepertoireDuGenome]/protembl2/$Nom"]
}
# name chrom strand txStart txEnd cdsStart cdsEnd exonCount exonStarts exonEnds proteinID alignID
proc LocUcscEvi {Nom {FromWhere ""} {AllLoc ""}} {
set LesLignesLocUcsc {}
set AllLoc [string equal -nocase "AllLoc" $AllLoc]
set Acc [AccessEvi $Nom]
if {$FromWhere==""} { set FromWhere "From200602" }
if {$FromWhere=="From200602"} {
set LigneLocUcsc [LocUcsc $Acc "line"]
set LigneNewAcc [LocUcsc PolyLocalisationOf $Acc]
set LesNewsAcc [split $LigneNewAcc " "]
lappend LesLignesLocUcsc $LigneLocUcsc
foreach New $LesNewsAcc {
lappend LesLignesLocUcsc [LocUcsc $New "line"]
}
}
set Name ""; set Chrom ""; set Strand ""; set TxStart ""; set TxEnd ""
scan $LigneLocUcsc "%s %s %s %s %s" Name Chrom Strand TxStart TxEnd
set LocUcscEvi "$Chrom:$TxStart-$TxEnd ($Strand)"
if { ! $AllLoc} { return $LocUcscEvi }
if {$AllLoc && $LocUcscEvi==":- ()"} { return $LocUcscEvi }
foreach LigneLocUcsc $LesLignesLocUcsc {
set Name ""; set Chrom ""; set Strand ""; set TxStart ""; set TxEnd ""
scan $LigneLocUcsc "%s %s %s %s %s" Name Chrom Strand TxStart TxEnd
set LocUcscEvi "$Chrom:$TxStart-$TxEnd ($Strand)"
lappend LesLUE $LocUcscEvi
}
return $LesLUE
}
proc InformeAffyPourTous {} {
foreach Nom [ListeDesPABs] {
set LesProbeAccess {}
set LesProbeLocUcsc {}
set LocUcsc {}
set LesLocAffy {}
set Access [AccessEvi $Nom]
if {$Access!=""} {
set LocUcsc [LocUcscEvi $Access "From200503"]
foreach ProbeAccess [lsort -unique [AffyAnno $Access "Probe_Set_ID"]] {
lappend LesProbeAccess $ProbeAccess
lappend LesLocAffy [AffyAnno $ProbeAccess "Alignments"]
}
set LesProbeLocUcsc [AffyAnno $LocUcsc "Probe_Set_ID"]
}
Espionne ""
Espionne "$Nom"
Espionne "Access =$Access"
Espionne "ProbeAccess =$LesProbeAccess"
Espionne "ProbeLocUcsc=$LesProbeLocUcsc"
Espionne "LocUcsc =$LocUcsc"
Espionne "LocAffy =$LesLocAffy"
}
}
proc VerifieCoherenceGscopeBioArrayBase {{Schema ""} {FromWhere ""}} {
if {$FromWhere==""} { set FromWhere "FromInfo" }
if {$Schema==""} { set Schema "poidevin" }
CanalSqlBioArrayBase
foreach Nom [ListeDesPABs] {
set TxStartSql ""
set TxEndSql ""
set TxStart ""
set TxEnd ""
if {$Schema=="poidevin"} {
set Li [SqlExec "select tsstart,tsstop from retinobase2.probeset where gscopeid = '$Nom';" "GetList"]
Espionne "LI $Li"
ScanLaListe $Li TxStartSql TxEndSql
}
if {$Schema=="retinobase2"} {
set Access [AccessEvi $Nom]
if {$Access==""} { continue }
set Li [SqlExec "select chromo_loc from retinobase2.probeset where accno = '$Access';" "GetList"]
Espionne "LI for $Nom $Access $Li"
if {$Li==""} { continue }
set StrandSql "?"
regsub {\-} $Li " " Li
regsub -all {[\:\(\)]} $Li " " Li
scan $Li "%s %s %s %s" ChromSql TxStartSql TxEndSql StrandSql
}
if {$FromWhere=="FromInfo"} {
set Loc [ExtraitInfo $Nom "InfoLocUcsc"]
scan $Loc "%s %s %s %s %s" NomLu Chrom Strand TxStart TxEnd
}
if {$FromWhere=="From200508"} {
set Access [AccessEvi $Nom]
set Strand "?"
regsub {\-} $Loc " " Loc
regsub -all {[\:\(\)]} $Loc " " Loc
scan $Loc "%s %s %s %s" Chrom TxStart TxEnd Strand
}
if {$FromWhere=="From200503"} {
set Access [AccessEvi $Nom]
set Loc [LocUcscEvi $Access "From200503"]
puts $Loc
set Strand "?"
regsub {\-} $Loc " " Loc
puts $Loc
regsub -all {[\:\(\)]} $Loc " " Loc
puts $Loc
scan $Loc "%s %s %s %s" Chrom TxStart TxEnd Strand
}
Espionne "Loc for $Access $FromWhere $Loc"
Espionne "$Nom $TxStart $TxEnd $FromWhere"
Espionne "$Nom $TxStartSql $TxEndSql $Schema"
Espionne ""
if {$TxStartSql>$TxEnd || $TxStart>$TxEndSql } { FaireLire horreur }
}
CanalSqlDisconnect
}
proc RangeGbNmFromNcbiEnStock {} {
}
proc LignesParGb GB {
return [GbsParLigne $GB]
}
proc GbsParLigne I {
global GbsParLigne
if {[info exists GbsParLigne($I)]} { return $GbsParLigne($I) }
if {[info exists GbsParLigne("EstCharge")]} { return {} }
set GbsParLigne("EstCharge") 1
set FichierGbsParLigne "[Fiches]/GbsParLigne"
array set GbsParLigne [LesLignesDuFichier $FichierGbsParLigne]
foreach {C Vs} [array get GbsParLigne] {
foreach V [split $Vs " "] {
if {[info exists GbsParLigne($V)]} { lappend GbsParLigne(GbMultiple) $V }
lappend GbsParLigne($V) $C
}
}
set GbsParLigne(GbMultiple) [lsort -unique $GbsParLigne(GbMultiple)]
set GbsParLigne(Vide) {}
foreach L [RetChip ListOf Index] {
if {[GbsParLigne $L]=={}} { lappend GbsParLigne(Vide) $L }
}
return [GbsParLigne $I]
}
proc LignesParNm NM {
return [NmsParLigne $NM]
}
proc NmsParLigne I {
global NmsParLigne
if {[info exists NmsParLigne($I)]} { return $NmsParLigne($I) }
if {[info exists NmsParLigne("EstCharge")]} { return {} }
set NmsParLigne("EstCharge") 1
set FichierNmsParLigne "[Fiches]/NmsParLigne"
array set NmsParLigne [LesLignesDuFichier $FichierNmsParLigne]
foreach {C Vs} [array get NmsParLigne] {
foreach V [split $Vs " "] {
if {[info exists NmsParLigne($V)]} { lappend NmsParLigne(NmMultiple) $V }
lappend NmsParLigne($V) $C
}
}
set NmsParLigne(NmMultiple) [lsort -unique $NmsParLigne(NmMultiple)]
set NmsParLigne(Vide) {}
foreach L [RetChip ListOf Index] {
if {[NmsParLigne $L]=={}} { lappend NmsParLigne(Vide) $L }
}
return [NmsParLigne $I]
}
proc GbEnStock GB {
global GbEnStock
if {[info exists GbEnStock($GB)]} { return $GbEnStock($GB) }
if {[info exists GbEnStock("EstCharge")]} { return "" }
set GbEnStock("EstCharge") 1
set FichierGbEnStock "[Fiches]/GbEnStock"
set Redondance 0
foreach Ligne [LesLignesDuFichier $FichierGbEnStock] {
if { ! [regexp -nocase {[a-z0-9/]} $Ligne]} { continue }
if {[regexp {^LOCUS +[A-Z]} $Ligne]} {
set GbLu [StringApres LOCUS dans $Ligne]
if {[info exists GbEnStock($GbLu)]} { set Redondance 1 ; unset GbEnStock($GbLu)}
set GbCourant $GbLu
set GbEnStock($GbCourant) $Ligne
lappend LesGbLus $GbLu
continue
}
if {[regexp {^ACCESSION +[A-Z]} $Ligne]} {
set GbEnStock($GbCourant,Accession) [StringApres "ACCESSION" dans $Ligne]
}
append GbEnStock($GbCourant) "\n$Ligne"
if {[regexp "//" $Ligne] && [info exists GbEnStock($GbCourant,Accession)]} {
set GbEnStock($GbEnStock($GbCourant,Accession)) $GbEnStock($GbCourant)
}
}
if {$Redondance} {
set FichierGbEnStockNew [TmpFile]
foreach GbLu $LesGbLus {
AppendAuFichier $FichierGbEnStockNew $GbEnStock($GbLu)
}
Garde $FichierGbEnStock
file rename -force $FichierGbEnStockNew $FichierGbEnStock
}
return [GbEnStock $GB]
}
proc NmEnStock NM {
global NmEnStock
if {[info exists NmEnStock($NM)]} { return $NmEnStock($NM) }
if {[info exists NmEnStock("EstCharge")]} { return "" }
set NmEnStock("EstCharge") 1
set FichierNmEnStock "[Fiches]/NmEnStock"
set Redondance 0
foreach Ligne [LesLignesDuFichier $FichierNmEnStock] {
if { ! [regexp -nocase {[a-z0-9/]} $Ligne]} { continue }
if {[regexp {^LOCUS +NM} $Ligne]} {
set NmLu [StringApres LOCUS dans $Ligne]
if {[info exists NmEnStock($NmLu)]} { set Redondance 1 ; unset NmEnStock($NmLu) }
set NmCourant $NmLu
set NmEnStock($NmCourant) $Ligne
continue
}
append NmEnStock($NmCourant) "\n$Ligne"
}
if {$Redondance} {
set FichierNmEnStockNew [TmpFile]
foreach NmLu [array names NmEnStock] {
AppendAuFichier $FichierNmEnStockNew $NmEnStock($NmLu)
}
Garde $FichierNmEnStock
file rename -force $FichierNmEnStockNew $FichierNmEnStock
}
return [NmEnStock $NM]
}
proc InventaireDesNMsEtGBs {} {
set LesNMs {}
set LesGBs {}
foreach I [RetChip ListOf Index] {
foreach C [list "refseq_PIQOR" "DNA_acc"] {
set NM [RetChip $I $C]
if { ! [regexp {^NM_[0-9]+$} $NM]} {
if {[regexp "," $NM]} {
set SesNMs [split $NM ","]
foreach NM $SesNMs {
if {[regexp {^NM_[0-9]+$} $NM]} {
lappend LesNMs $NM ; lappend LesNMsDu($I) $NM; continue
}
}
continue
}
}
if {$NM==""} { continue }
if {[regexp {^NM_[0-9]+$} $NM]} {
lappend LesNMs $NM ; lappend LesNMsDu($I) $NM; continue
}
Espionne "GB $NM"
if {[regexp {^[A-Z]+[0-9]+$} $NM]} {
lappend LesGBs $NM ; lappend LesGBsDu($I) $NM; continue
}
}
}
set LesNMs [lsort -unique $LesNMs]
set LesGBs [lsort -unique $LesGBs]
if {[OuiOuNon "Do I look for missing NM and GB at NCBI ?"]} {
set LesVides {}
set Fichier "[Fiches]/GbNmFromNcbiEnStock"
if {[file exists $Fichier] && [OuiOuNon "Do I replace $Fichier ?"]} { file delete $Fichier }
foreach X [concat $LesNMs $LesGBs] {
if {[NmEnStock $X]!=""} { continue }
if {[GbEnStock $X]!=""} { continue }
set NCBI [FromNCBI $X]
if {$NCBI==""} { lappend LesVides $X }
AppendAuFichier $Fichier $NCBI
}
return
}
SauveLesLignes [array get LesNMsDu] dans "[Fiches]/NmsParLigne"
SauveLesLignes [array get LesGBsDu] dans "[Fiches]/GbsParLigne"
set KeepEnStock [OuiOuNon "Do I keep existing NmEnStock (and GbEnStock) ?"]
set LesRestants $LesNMs
if {$KeepEnStock} {
set LesRestants {}
foreach NM $LesNMs {
if {[NmEnStock $NM]!=""} { continue }
lappend LesRestants $NM
}
}
Espionne $LesRestants
set Fichier "[Fiches]/NmEnStock"
if {[file exists $Fichier] && [OuiOuNon "Do I replace $Fichier ?"]} { file delete $Fichier }
while 1 {
if {$LesRestants=={}} { break }
set LesCourants [lrange $LesRestants 0 99]
set LesRestants [lrange $LesRestants 100 end]
set NMs [join $LesCourants "|"]
set GetzCourant [Getz $NMs refseq]
set T [regexp -all {\|} $NMs] ; incr T
set N [regexp -all "//" $GetzCourant]
Espionne "Recu $N sur $T"
AppendAuFichier $Fichier $GetzCourant
}
set LesRestants $LesGBs
if {$KeepEnStock} {
set LesRestants {}
foreach GB $LesGBs {
if {[GbEnStock $GB]!=""} { continue }
lappend LesRestants $GB
}
}
Espionne $LesRestants
set Fichier "[Fiches]/GbEnStock"
if {[file exists $Fichier] && [OuiOuNon "Do I replace $Fichier ?"]} { file delete $Fichier }
while 1 {
if {$LesRestants=={}} { break }
set LesCourants [lrange $LesRestants 0 99]
set LesRestants [lrange $LesRestants 100 end]
set GBs [join $LesCourants "|"]
set GetzCourant [Getz $GBs genbank genbanknew]
set T [regexp -all {\|} $GBs] ; incr T
set N [regexp -all "//" $GetzCourant]
Espionne "Recu $N sur $T"
AppendAuFichier $Fichier $GetzCourant
}
exit
}
proc RetChip {Ligne Colonne} {
global RetChip
if {[info exists RetChip($Ligne,$Colonne)]} { return $RetChip($Ligne,$Colonne) }
if {[info exists RetChip("EstCharge")]} { return "" }
set RetChip("EstCharge") 1
#rR set FichierRetChip "[RepertoireDuGenome]/DeLaetitia/genoret_050909_sansPV.csv"
set FichierRetChip "[RepertoireDuGenome]/parser/AcNMetProt_v4.csv"
set Queue [file tail $FichierRetChip]
regsub -nocase {\.[^\.]+$} $Queue "" Queue
#rR LoadTxl
LoadTxl $FichierRetChip RetChip -1 ";"
set LesTetes $RetChip(ListHeaderPlease,$Queue)
set LesIndex $RetChip(ListAllPlease,$Queue)
#rR loadTxl
set RetChip(ListOf,Header) $LesTetes
set RetChip(ListOf,Index) $LesIndex
return [RetChip $Ligne $Colonne]
exit
}
proc TestAffyAnno {} {
foreach Index [AffyAnno ListOf Index] {
foreach Header [AffyAnno ListOf Header] {
Espionne "$Index $Header [AffyAnno $Index $Header]"
}
}
}
proc LocAffy {{Qui ""} {Quoi ""}} {
global LocAffy
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Arguments" }
if {[info exists LocAffy($Qui,$Quoi)]} { return $LocAffy($Qui,$Quoi) }
if {[info exists LocAffy("EstCharge")]} { return "" }
set LocAffy("EstCharge") 1
set Org "Mouse"
foreach P [AffyAnno ListOf Index] {
set Ali [AffyAnno $P "Alignments"]
regsub -all { */// *} $Ali "@" Ali
foreach Lo [split $Ali "@"] {
regsub -all { */+ *} $Lo "@" Lo
set LesChamps [split $Lo "@"]
set CSES [lindex $LesChamps 0]
regsub -all {[\:\-\(\)]} $CSES " " CSES
scan $CSES "%s %s %s %s" Chr Start End Strand
lappend LocAffy(ListOf$Org$Chr,StartEndName) "$Start $End $P"
set Cytoband [lindex $LesChamps 2]
lappend LocAffy(ListOf$Org$Chr,CytobandName) "$Cytoband $P"
}
}
set LocAffy(ListOf,Arguments) [array names LocAffy]
foreach V $LocAffy(ListOf,Arguments) {
if {[regexp "StartEndName$" $V]} {
set LocAffy($V) [lsort -integer -index 0 $LocAffy($V)]
}
if {[regexp "CytobandName$" $V]} {
set LocAffy($V) [lsort $LocAffy($V)]
}
}
return [LocAffy $Qui $Quoi]
}
proc AffyAnnoAllFields Probe {
foreach Tete [AffyAnno ListOf Header] {
lappend LaSortie "[format %33s $Tete] [AffyAnno $Probe $Tete]"
}
return [join $LaSortie "\n"]
}
proc AffyAnno {{Ligne ""} {Colonne ""}} {
#attention un nouvelle version
global AffyAnno
if {$Ligne==""} { set Ligne "ListOf" }
if {$Colonne==""} { set Colonne "Header" }
if {[info exists AffyAnno($Ligne,$Colonne)]} { return $AffyAnno($Ligne,$Colonne) }
if {[info exists AffyAnno("EstCharge")]} { return "" }
set AffyAnno("EstCharge") 1
set FichierAffyAnno "[RepertoireDuGenome]/fiches/AffyAnno"
if {[file exists $FichierAffyAnno]} {
array set AffyAnno [LesLignesDuFichier $FichierAffyAnno]
return [AffyAnno $Ligne $Colonne]
}
set CreeFichierAffyAnno [OuiOuNon "Do I create $FichierAffyAnno ?"]
set AffyAnno(ListOf,Header) {}
set AffyAnno(ListOf,Index) {}
set LesFichiersAffyAnno [list \
"/genomics/link/affyArrayAnnot/AffyAnno20070309/MGU74v2/MG_U74Av2.na22.annot.csv" \
"/genomics/link/affyArrayAnnot/AffyAnno20070309/MGU74v2/MG_U74Bv2.na22.annot.csv" \
"/genomics/link/affyArrayAnnot/AffyAnno20070309/MGU74v2/MG_U74Cv2.na22.annot.csv" \
"/genomics/link/affyArrayAnnot/AffyAnno20070309/MG430_2.0/Mouse430_2.na22.annot.csv" \
"/genomics/link/affyArrayAnnot/AffyAnno20070309/MG430A_2.0/Mouse430A_2.na22.annot.csv" ]
set LesTetes {}
set LesIndex {}
foreach CurrentFichierAffyAnno $LesFichiersAffyAnno {
Espionne "$CurrentFichierAffyAnno"
set Queue [file tail $CurrentFichierAffyAnno]
Espionne "$Queue"
regsub -nocase {\.[^\.]+$} $Queue "" Queue
Espionne "$Queue"
LoadTxlAffy $CurrentFichierAffyAnno AffyAnno 0 ","
set LesNouvellesTetes $AffyAnno(ListHeaderPlease,$Queue)
Espionne "$LesTetes"
Espionne "++"
Espionne "$LesNouvellesTetes"
if {$LesTetes=={}} { set LesTetes $LesNouvellesTetes }
if {$LesTetes!=$LesNouvellesTetes} { FaireLire "The headers are different in [join $LesFichiersAffyAnno "\n"]" }
LConcat LesIndex $AffyAnno(ListAllPlease,$Queue)
}
set AffyAnno(ListOf,Header) $LesTetes
set AffyAnno(ListOf,Index) $LesIndex
if {$CreeFichierAffyAnno} {
SauveLesLignes [array get AffyAnno] dans $FichierAffyAnno
}
return [AffyAnno $Ligne $Colonne]
}
proc BonneTete {Tete} {
global BonneTete
if {[info exists BonneTete($Tete)]} { return $BonneTete($Tete) }
if {[info exists BonneTete("EstCharge")]} { return 0 }
set BonneTete("EstCharge") 1
set BonneTete(Probe_Set_ID) 1
set BonneTete(GeneChip_Array) 1
set BonneTete(Species_Scientific_Name) 1
set BonneTete(Annotation_Date) 1
set BonneTete(Sequence_Type) 1
set BonneTete(Representative_Public_ID) 1
set BonneTete(UniGene_ID) 1
set BonneTete(Genome_Version_) 1
set BonneTete(Alignments) 1
set BonneTete(Gene_Title) 1
set BonneTete(Gene_Symbol) 1
set BonneTete(Ensembl) 1
set BonneTete(Entrez_Gene) 1
set BonneTete(SwissProt) 1
set BonneTete(OMIM) 1
set BonneTete(RefSeq_Protein_ID) 1
set BonneTete(RefSeq_Transcript_ID) 1
set BonneTete(Gene_Ontology_Biological_Process) 1
set BonneTete(Gene_Ontology_Cellular_Component) 1
set BonneTete(Gene_Ontology_Molecular_Function) 1
set BonneTete(Pathway) 1
set BonneTete(InterPro) 1
set BonneTete(Trans_Membrane) 1
set BonneTete(ListAll) [array names BonneTete]
set BonneTete(GrandChef) "Probe_Set_ID"
set BonneTete(ListChef) [list "RefSeq_Transcript_ID" "Alignments" "Representative_Public_ID" "SwissProt" "RefSeq_Protein_ID"]
foreach Chef $BonneTete(ListChef) {
set BonneTete($Chef-IsChef) 1
}
lappend BonneTete(ListOfReferents) "Alignments"
set BonneTete(ListChefForAlignments) [list "RefSeq_Transcript_ID" "Representative_Public_ID"]
return [BonneTete $Tete]
}
proc LoadTxlAffy {Fichier {aTxl ""} {MainIndex 0} {Sep ""} {CoLi ""}} {
Wup "Attention BonSep n'est pas utilise, ca ne marche que pour \",\""
set BonSep $Sep
if {[regexp {[\,\-\;]} $BonSep]} { set BonSep "\\$Sep" }
if {$CoLi==""} { set CoLi "LiCo" }
Wup "Normally the values are stored in Txl(Line,Column)"
Wup " with CoLi==CoLi we have Txl(Column,Line)"
if {$aTxl!=""} { upvar $aTxl Txl } else { global Txl ; set aTxl Txl }
if {$Sep==""} { set Sep "\t" }
set Queue [file tail $Fichier]
regsub -nocase {\.[^\.]+$} $Queue "" Queue
if { ! [file exists $Fichier]} {
set Txl(ListHeaderPlease,$Queue) {}
set Txl(ListAllPlease,$Queue) {}
return $aTxl
}
#LP
#set LesLignes [LesLignesDuFichier $Fichier]
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp "^#" $Ligne]} {continue}
lappend LesLignes $Ligne
}
#LP
set Entete [lindex $LesLignes 0]
set LesLignes [lrange $LesLignes 1 end]
set LesTetes {}
foreach Tete [split $Entete $Sep] {
regsub -all {\(} $Tete "" Tete
regsub -all {\)} $Tete "" Tete
regsub -all {\"} $Tete "" Tete
regsub -all { } $Tete "_" Tete
lappend LesTetes $Tete
}
set Txl(ListHeaderPlease,$Queue) $LesTetes
set I 1
foreach Ligne $LesLignes {
incr I
regsub -all "@" $Ligne "A=r=O=b=A"
set BelleLigne [string trim $Ligne {\"}]
regsub -all {\"\,\"} $BelleLigne "@" BelleLigne
set LesMots [split $BelleLigne "@"]
if {$MainIndex<0} {
set Nom $I
} else {
set Nom [lindex $LesMots $MainIndex]
regsub -all {\"} $Nom "" Nom
}
lappend Txl(ListAllPlease,$Queue) $Nom
if {[info exists DejaVu]} {unset DejaVu}
foreach Mot $LesMots Tete $LesTetes {
#LP
if {$Tete=="RefSeq_Protein_ID"} {
if {[regexp "." $Mot]} {
set Mot [lindex [split $Mot "."] 0]
}
}
#LP
set MemoValeur($Tete) $Mot
if {$Tete==""} { continue }
if { ! [BonneTete $Tete]} { continue }
regsub -all {"A=r=O=b=A"} $Mot "@" Mot
regsub -all {\"} $Mot "" Mot
set LesPetitsMots [LesBoutsDeLaLigneAvecTexteSeparateur $Mot "///" "trim"]
if {$CoLi=="CoLi"} {
if {[info exists Txl($Tete,$Nom)]} {
if {$Txl($Tete,$Nom)!=$Mot} { append Txl($Tete,$Nom) " -or- $Mot" }
} else {
set Txl($Tete,$Nom) $Mot
}
if {[BonneTete "$Tete-IsChef"]} {
foreach PetitMot $LesPetitsMots {
if {[set iSS [string first {//} $PetitMot]]>0} {
set PetitMot [string range $PetitMot 0 [incr iSS -1]]
set PetitMot [string trim $PetitMot]
}
lappend Txl([BonneTete "GrandChef"],$PetitMot) $Nom
}
}
} else {
if {[info exists Txl($Nom,$Tete)]} {
if {$Txl($Nom,$Tete)!=$Mot} { append Txl($Nom,$Tete) " -or- $Mot" }
} else {
set Txl($Nom,$Tete) $Mot
}
if {[BonneTete "$Tete-IsChef"]} {
foreach PetitMot $LesPetitsMots {
if {[set iSS [string first {//} $PetitMot]]>=0} {
set PetitMot [string range $PetitMot 0 [incr iSS -1]]
set PetitMot [string trim $PetitMot]
}
lappend Txl($PetitMot,[BonneTete "GrandChef"]) $Nom
}
}
}
}
foreach Referent [BonneTete ListOfReferents] {
foreach Chef [BonneTete ListChefFor$Referent] {
if {$CoLi=="CoLi"} {
lappend Txl($Referent,$MemoValeur($Chef)) $MemoValeur($Referent)
} else {
lappend Txl($MemoValeur($Chef),$Referent) $MemoValeur($Referent)
}
}
}
}
return $aTxl
}