Index by: file name |
procedure name |
procedure call |
annotation
gscope_lca.tcl
(annotations | original source)
#rR genoret_lca.tcl
proc MutationMisSensProtein {{GetWhat ""}} {
foreach M [MutationMTM ListAllPlease MutationsMTM-MisSens MisSens] {
set F [MutationMTM $M Phenotype MisSens]
set P [MutationMTM $M Predicted_protein_or_splicing_alteration MisSens]
set P [string trim $P " ,"]
lappend LesMisSens "$P $F"
}
if {[string equal -nocase $GetWhat "GetList"]} { return $LesMisSens }
return [AfficheVariable [join $LesMisSens "\n"] "" "LesMisSens"]
}
proc MergeMTM {} {
set LesHeaderRR [MutationRR ListOf Header]
set LesHeaderVB [MutationVB ListOf Header]
set LesLignes {}
lappend LesLignes [join $LesHeaderVB ";"]
foreach Pid [MutationVB ListOf Pid] {
set LesV {}
foreach H $LesHeaderVB {
set V [MutationVB $Pid $H]
lappend LesV $V
}
lappend LesLignes [join $LesV ";"]
}
foreach Pid [MutationPolyVB ListOf Pid] {
Espionne $Pid
set LesV {}
foreach H $LesHeaderVB {
set V [MutationPolyVB $Pid $H]
lappend LesV $V
}
lappend LesLignes [join $LesV ";"]
}
return [SauveLesLignes $LesLignes dans "MutationMTM-20081127.csv"]
exit
}
proc CompareMTM {} {
set LesHeaderRR [MutationRR ListOf Header]
set LesHeaderVB [MutationVB ListOf Header]
foreach H $LesHeaderRR {
foreach Pid [MutationVB ListOf Pid] {
if {[MutationRR $Pid $H]!=[MutationVB $Pid $H]} { Espionne "$Pid $H [MutationRR $Pid $H]!=[MutationVB $Pid $H]" }
}
}
foreach H $LesHeaderVB {
if { [lsearch $LesHeaderRR $H] < 0 } { lappend LesNouveauxHeaders $H; continue }
foreach Pid [MutationVB ListOf Pid] {
if {[MutationRR $Pid $H]!=[MutationVB $Pid $H]} { Espionne "$Pid $H [MutationRR $Pid $H]!=[MutationVB $Pid $H]" }
}
}
foreach H $LesNouveauxHeaders {
set LesNouveaux {}
foreach Pid [MutationVB ListOf Pid] {
lappend LesNouveaux [MutationVB $Pid $H]
}
set LesNouveaux [lsort -unique $LesNouveaux]
AfficheVariable [join $LesNouveaux "\n"] "" $H
}
}
proc MutationRR {{Qui ""} {Quoi ""}} {
global MutationRR
if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }
if {[info exists MutationRR($Qui,$Quoi)]} { return $MutationRR($Qui,$Quoi) }
if {[info exists MutationRR("EstCharge")]} { return "" }
set MutationRR("EstCharge") 1
set Rep "[HomeRipp]/GenoretWww/Collaboration/MutationsMTM"
set F "$Rep/MutationsMTM.csv"
if {[info exists T]} { unset T }
LoadTxlWithRowsOfCells $F T 0 ";" "" "WholeLine"
set MutationRR(ListOf,Header) $T(ListHeaderPlease,)
set MutationRR(ListOf,Pid) $T(ListAllPlease,)
foreach {C V} [array get T] {
set MutationRR($C) $V
}
return [MutationRR $Qui $Quoi]
}
proc MutationVB {{Qui ""} {Quoi ""}} {
global MutationVB
if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }
if {[info exists MutationVB($Qui,$Quoi)]} { return $MutationVB($Qui,$Quoi) }
if {[info exists MutationVB("EstCharge")]} { return "" }
set MutationVB("EstCharge") 1
set Rep "[HomeRipp]/GenoretWww/Collaboration/MutationsMTM"
# set F "$Rep/MutationsMTMv2Poly-VBcorrigeRR.csv"
set F "$Rep/MutationsMTMv2-VBcorrigeRR.csv"
if {[info exists T]} { unset T }
LoadTxlWithRowsOfCells $F T 0 ";" "" "WholeLine"
set MutationVB(ListOf,Header) $T(ListHeaderPlease,)
set MutationVB(ListOf,Pid) $T(ListAllPlease,)
foreach {C V} [array get T] {
set MutationVB($C) $V
}
return [MutationVB $Qui $Quoi]
}
proc MutationPolyVB {{Qui ""} {Quoi ""}} {
global MutationPolyVB
if {$Qui==""} { set Qui "ListOf"; set Quoi "Header" }
if {[info exists MutationPolyVB($Qui,$Quoi)]} { return $MutationPolyVB($Qui,$Quoi) }
if {[info exists MutationPolyVB("EstCharge")]} { return "" }
set MutationPolyVB("EstCharge") 1
set Rep "[HomeRipp]/GenoretWww/Collaboration/MutationsMTM"
set F "$Rep/MutationsMTMv2Poly-VBcorrigeRR.csv"
if {[info exists T]} { unset T }
LoadTxlWithRowsOfCells $F T 0 ";" "" "WholeLine"
set MutationPolyVB(ListOf,Header) $T(ListHeaderPlease,)
set MutationPolyVB(ListOf,Pid) $T(ListAllPlease,)
foreach {C V} [array get T] {
set MutationPolyVB($C) $V
}
return [MutationPolyVB $Qui $Quoi]
}
proc MTM1 {{Qui ""} {Quoi ""} {Deb ""} {Fin ""}} {
global MTM1
if {[info exists MTM1("EstCharge")]} {
if {$Qui=="" || $Qui=="show" && $Quoi==""} {
set Show [string equal $Qui "show"]
set QQDF [ChoixParmi [MTM1 ListOf Keys]]
set O [set D [set F ""]]
ScanLaListe [split $QQDF ","] Q O D F
set R [MTM1 $Q $O $D $F]
if {$Show} { return [AfficheVariable $R] }
return $R
}
if {$Qui=="show"} {
set What "seq"
if {$Quoi=="gb"} { set What "gb" ; set Quoi "text" }
set Titre [join [list $What $Quoi $Deb $Fin] "_"]
return [AfficheVariable [MTM1 $What $Quoi $Deb $Fin] "AvecFormat" $Titre]
}
if {[info exists MTM1($Qui,$Quoi,$Deb,$Fin)] } { return $MTM1($Qui,$Quoi,$Deb,$Fin) }
if {[info exists MTM1($Qui,$Quoi,$Deb)] && $Fin==""} { return $MTM1($Qui,$Quoi,$Deb) }
if {[info exists MTM1($Qui,$Quoi)] && $Deb=="" && $Fin==""} { return $MTM1($Qui,$Quoi) }
if {[info exists MTM1($Qui)] && $Quoi=="" && $Deb=="" && $Fin==""} { return $MTM1($Qui) }
if {$Fin==""} { set Fin $Deb }
if {$Qui=="seq" && $Quoi!=""} {
return [string range $MTM1($Qui,$Quoi) [expr $Deb-1] [expr $Fin-1]]
}
return ""
}
set MTM1("EstCharge") 1
set FichierGene "[HomeRipp]/GenoretWww/Collaboration/MutationsMTM/MTM1gene.gb"
set GB [ContenuDuFichier $FichierGene]
set MTM1(gb,text) $GB
set MTM1(gb,filename) $FichierGene
set Access [StringApres "LOCUS" dans $GB]
set MTM1(access) $Access
set Definition [StringSuivant "DEFINITION " dans $GB]
regsub {\n.*} $Definition "" Definition
set MTM1(definition) $Definition
set ZonesMrna [StringSuivant " mRNA join(" dans $GB]
regsub {\).*} $ZonesMrna "" ZonesMrna
regsub -all {[^0-9\.\,]} $ZonesMrna "" ZonesMrna
foreach Zone [split $ZonesMrna ","] {
regsub {\.\.} $Zone " " Zone
scan $Zone "%d %d" D F
lappend LesDFexonMrna $D $F
}
set LesDFintronMrna {}
foreach {D F} [lrange $LesDFexonMrna 1 end-1] {
lappend LesDFintronMrna [expr $D+1] [expr $F-1]
}
set MTM1(exonmrna,ListOf,startstop) $LesDFexonMrna
set MTM1(intronmrna,ListOf,startstop) $LesDFintronMrna
set ZonesCds [StringSuivant " CDS join(" dans $GB]
regsub {\).*} $ZonesCds "" ZonesCds
regsub -all {[^0-9\.\,]} $ZonesCds "" ZonesCds
set LesDFexon {}
foreach Zone [split $ZonesCds ","] {
regsub {\.\.} $Zone " " Zone
scan $Zone "%d %d" D F
lappend LesDFexon $D $F
}
set LesDFintron {}
foreach {D F} [lrange $LesDFexon 1 end-1] {
lappend LesDFintron [expr $D+1] [expr $F-1]
}
set MTM1(exon,ListOf,startstop) $LesDFexon
set MTM1(intron,ListOf,startstop) $LesDFintron
set MTM1(exoncds,ListOf,startstop) $LesDFexon
set MTM1(introncds,ListOf,startstop) $LesDFintron
set SeqGene [StringSuivant "\nORIGIN" dans $GB]
regsub -nocase -all {[^a-z]} $SeqGene "" SeqGene
set SeqGene [string toupper $SeqGene]
set nSeqGene "n$SeqGene"
set CdsStart [lindex $LesDFexon 0]
set CdsStop [lindex $LesDFexon end]
set MTM1(csd,start) $CdsStart
set MTM1(csd,stop) $CdsStop
set MTM1(seq,gene) $SeqGene
set MTM1(tfa,gene) [SequenceFormatTFA $MTM1(seq,gene) "gene_$Access $Definition (gene)"]
set LesDFexon5utr {}
set LesDFexon3utr [list [expr $CdsStop+1]]
set LaSeq {}
foreach {D F} $LesDFexonMrna {
if {$D<$CdsStart} { lappend LesDFexon5utr $D }
if {$F<$CdsStart} { lappend LesDFexon5utr $F }
if {$D>$CdsStop } { lappend LesDFexon3utr $D }
if {$F>$CdsStop } { lappend LesDFexon3utr $F }
set SeqMrna [string range $nSeqGene $D $F]
lappend LaSeq $SeqMrna
}
lappend LesDFexon5utr [expr $CdsStart-1]
set MTM1(exon5utr,ListOf,startstop) $LesDFexon5utr
set MTM1(exon3utr,ListOf,startstop) $LesDFexon3utr
set MTM1(seq,mrna) [join $LaSeq ""]
set MTM1(tfa,mrna) [SequenceFormatTFA $MTM1(seq,mrna) "mrna_$Access $Definition (mrna)"]
set exI 0
set LaSeq {}
foreach {D F} $LesDFexon {
incr exI
set SeqEx [string range $nSeqGene $D $F]
set MTM1(seq,exon$exI) $SeqEx
lappend LaSeq $SeqEx
}
set MTM1(seq,cds) [join $LaSeq ""]
set MTM1(tfa,cds) [SequenceFormatTFA $MTM1(seq,cds) "cds_$Access $Definition (cds)"]
set inI 0
foreach {D F} $LesDFintron {
incr inI
set SeqIn [string range $nSeqGene $D $F]
set MTM1(seq,intron$inI) $SeqIn
}
set MTM1(ListOf,Keys) [lsort [array names MTM1]]
return [MTM1 $Qui $Quoi $Deb $Fin]
}
proc TestMutationMTM {{Type ""}} {
if {$Type==""} { set Type "MisSens" }
foreach H [MutationMTM ListHeaderPlease $Type] {
foreach I [MutationMTM ListAllPlease $Type] {
set Header [format "%30s" $H]
set Valeur [MutationMTM $I $H $Type]
set BeauI [format "%3d" $I]
lappend LesLignes "$Header :$BeauI:=$Valeur= [MutationMTM $I Patients $Type]"
}
}
set Texte [join $LesLignes "\n"]
AfficheVariable $Texte "" $Type
}
proc CollecteMutationMTM {{Qui ""} {Quoi ""}} {
global CollecteMutationMTM
if {$Qui==""} { set Qui "ListOf"; set Quoi "Types" }
if {[info exists CollecteMutationMTM($Qui,$Quoi)]} { return $CollecteMutationMTM($Qui,$Quoi) }
if {[info exists CollecteMutationMTM("EstCharge")]} {
if {$Qui=="Get" && $Quoi=="Csv"} {
set LeTout {}
lappend LeTout [join [CollecteMutationMTM "ListOf" "Keys"] ";"]
foreach P [CollecteMutationMTM "ListOf" "Patients"] {
lappend LeTout [join [CollecteMutationMTM $P "allvalues"] ";"]
}
set Tout [join $LeTout "\n"]
return $Tout
}
return ""
}
set CollecteMutationMTM("EstCharge") 1
set LesTypes [MutationMTM ListOf Possible Type]
set CollecteMutationMTM(ListOf,Types) [MutationMTM ListOf Possible Type]
foreach Type $LesTypes {
CollecteMutationMTMForType $Type
}
return [CollecteMutationMTM $Qui $Quoi]
}
proc CollecteMutationMTMForType {{Type ""}} {
global CollecteMutationMTM
set Seq [QueLaSequenceDuFichierTFA "[HomeRipp]/GenoretWww/Collaboration/MutationsMTM/MTM1.tfa"]
set Seq [string toupper $Seq]
set Seq "n$Seq"
if {$Type==""} { set Type "MisSens" }
set Oblige "Nucleotide_change"
set LesTrois {}
set LesErreurs {}
set OldMut "trululu"
set NbDeLaMut 1
set TotalNbCourant -1
set TotalNbPrecedant -1
set LesHeaders [MutationMTM ListHeaderPlease $Type]
foreach I [MutationMTM ListAllPlease $Type] {
set WL [MutationMTM $I "WholeLine" $Type]
set TotalNbLu [MutationMTM $I "Total_nb" $Type]
if {$TotalNbLu!=""} { set TotalNbCourant $TotalNbLu}
set Mutation [MutationMTM $I $Oblige $Type]
regsub -all " " $Mutation "" Mutation
if {[regsub -all {\(? *\$.*} $Mutation "" Mutation]>0} { }
if {[regexp {\$} $Mutation]} { set Mutation [Entre $Mutation] }
if {$Mutation==""} { FaireLire "Horreur une mutation vide" }
set Base ""
if {[regexp -nocase {c.([0-9]+)([A-Z])>} $Mutation Match Pos Base]} {
set Base [string toupper $Base]
set Good [string index $Seq $Pos]
if { ! [string equal $Good $Base]} {
lappend LesErreurs "$Type $I $Mutation $Good $Base"
}
}
set SeqDel ""
if {[regexp -nocase {^c.([0-9]+)del([A-Z])$} $Mutation Match Pos SeqDel]} {
set SeqDel [string toupper $SeqDel]
set Good [string index $Seq $Pos]
if { ! [string equal $Good $SeqDel]} {
lappend LesErreurs "$Type $I $Mutation $Good $SeqDel"
}
} 82
if {[regexp -nocase {^c.([0-9]+)\-([0-9]+)del([A-Z]+)$} $Mutation Match PosD PosF SeqDel]} {
set SeqDel [string toupper $SeqDel]
set Good [string range $Seq $PosD $PosF]
if { ! [string equal $Good $SeqDel]} {
lappend LesErreurs "$Type $I $Mutation $Good $SeqDel"
}
}
if {$OldMut==$Mutation} {
lappend LesIsDeLaMut($Mutation) $I
incr NbDeLaMut
set TotalNbPrecedant $TotalNbCourant
} else {
if {$TotalNbPrecedant>0 && $TotalNbPrecedant!=$NbDeLaMut} {
lappend LesErreurs "$Type [expr $I-1] TotalNb $TotalNbPrecedant != $NbDeLaMut de $OldMut"
}
set TotalNbPrecedant $TotalNbCourant
set TotalNbCourant -1
set NbDeLaMut 1
set LesIsDeLaMut($Mutation) [list $I]
}
set FamilySize [llength $LesIsDeLaMut($Mutation)]
set OldMut $Mutation
set P [MutationMTM PatientCode $Type $I]
lappend CollecteMutationMTM(ListOf,Patients) $P
lappend CollecteMutationMTM(ListOf,patient) $P
set Protein ""
if {[set Pro [MutationMTM $I "Predicted_protein_change" $Type]]!=""} { set Protein $Pro }
if {[set Pro [MutationMTM $I "Predicted_protein_or_splicing_alteration" $Type]]!=""} { set Protein $Pro }
KeyList "PleaseReset"
set CollecteMutationMTM($P,[KeyList pid]) $P
set CollecteMutationMTM($P,[KeyList type]) $Type
set CollecteMutationMTM($P,[KeyList patient]) [MutationMTM $I "Patients" $Type]
set CollecteMutationMTM($P,[KeyList region]) [MutationMTM $I "Region" $Type]
set CollecteMutationMTM($P,[KeyList mutation]) $Mutation
set CollecteMutationMTM($P,[KeyList protein]) $Protein
set CollecteMutationMTM($P,[KeyList familysize]) $FamilySize
set CollecteMutationMTM($P,[KeyList phenotype]) [MutationMTM $I "Phenotype" $Type]
set CollecteMutationMTM($P,[KeyList conservation]) [MutationMTM $I "Conservation" $Type]
set CollecteMutationMTM($P,[KeyList frequence]) [MutationMTM $I "Frequence" $Type]
set CollecteMutationMTM($P,[KeyList evidence]) [MutationMTM $I "Preuve_=_poly" $Type]
set CollecteMutationMTM($P,[KeyList origine]) [MutationMTM $I "Mutation_origin" $Type]
set CollecteMutationMTM($P,[KeyList references]) [MutationMTM $I "References" $Type]
set CollecteMutationMTM($P,[KeyList comment]) [MutationMTM $I "RR" $Type]
foreach Im $LesIsDeLaMut($Mutation) {
set P [MutationMTM PatientCode $Type $Im]
set CollecteMutationMTM($P,familysize) $FamilySize
}
if { ! [info exists CollecteMutationMTM(ListOf,Keys)]} {
set CollecteMutationMTM(ListOf,Keys) [KeyList "PleaseGetKeys"]
}
foreach Key $CollecteMutationMTM(ListOf,Keys) {
lappend CollecteMutationMTM($P,allvalues) $CollecteMutationMTM($P,$Key)
}
set OldWL $WL
}
return
AfficheVariable [join $LesErreurs "\n"] "" "DetectedErrors"
set Texte [join $LesTrois "\n"]
return [AfficheVariable $Texte "" $Type]
}
proc FusionneMutationMTMPourTous {} {
foreach Type [MutationMTM ListOf Possible Type] {
FusionneMutationMTM $Type
}
}
proc FusionneMutationMTM {{Type ""}} {
set Seq [QueLaSequenceDuFichierTFA "[HomeRipp]/GenoretWww/Collaboration/MutationsMTM/MTM1.tfa"]
set Seq [string toupper $Seq]
set Seq "n$Seq"
if {$Type==""} { set Type "MisSens" }
set Oblige "Nucleotide_change"
set LesTrois {}
set LesErreurs {}
set OldMut "trululu"
set NbDeLaMut 1
set TotalNbCourant -1
set TotalNbPrecedant -1
set LesHeaders [MutationMTM ListHeaderPlease $Type]
Espionne $LesHeaders
foreach I [MutationMTM ListAllPlease $Type] {
set WL [MutationMTM $I "WholeLine" $Type]
set TotalNbLu [MutationMTM $I "Total_nb" $Type]
if {$TotalNbLu!=""} { set TotalNbCourant $TotalNbLu}
set Mutation [MutationMTM $I $Oblige $Type]
regsub -all " " $Mutation "" Mutation
if {[regsub -all {\(? *\$.*} $Mutation "" Mutation]>0} { }
if {[regexp {\$} $Mutation]} { set Mutation [Entre $Mutation] }
if {$Mutation==""} {
lappend LesTrois $OldWL
lappend LesTrois $WL
set Fus {}
foreach Mot1 $OldWL Mot2 $WL {
set Mot [string trim "[string trim $Mot1] // [string trim $Mot2]" " /"]
lappend Fus $Mot
}
lappend LesTrois $Fus
lappend LesTrois ""
} else {
set Base ""
if {[regexp -nocase {c.([0-9]+)([A-Z])>} $Mutation Match Pos Base]} {
set Base [string toupper $Base]
set Good [string index $Seq $Pos]
if { ! [string equal $Good $Base]} {
lappend LesErreurs "$Type $I $Mutation $Good $Base"
}
}
set SeqDel ""
if {[regexp -nocase {^c.([0-9]+)del([A-Z])$} $Mutation Match Pos SeqDel]} {
set SeqDel [string toupper $SeqDel]
set Good [string index $Seq $Pos]
if { ! [string equal $Good $SeqDel]} {
lappend LesErreurs "$Type $I $Mutation $Good $SeqDel"
}
}
if {[regexp -nocase {^c.([0-9]+)\-([0-9]+)del([A-Z]+)$} $Mutation Match PosD PosF SeqDel]} {
set SeqDel [string toupper $SeqDel]
set Good [string range $Seq $PosD $PosF]
if { ! [string equal $Good $SeqDel]} {
lappend LesErreurs "$Type $I $Mutation $Good $SeqDel"
}
}
Espionne "$OldMut $Mutation $TotalNbPrecedant $NbDeLaMut $TotalNbLu"
if {$OldMut==$Mutation} {
incr NbDeLaMut
set TotalNbPrecedant $TotalNbCourant
} else {
if {$TotalNbPrecedant>0 && $TotalNbPrecedant!=$NbDeLaMut} {
lappend LesErreurs "$Type [expr $I-1] TotalNb $TotalNbPrecedant != $NbDeLaMut de $OldMut"
}
set TotalNbPrecedant $TotalNbCourant
set TotalNbCourant -1
set NbDeLaMut 1
}
set OldMut $Mutation
}
set OldWL $WL
}
AfficheVariable [join $LesErreurs "\n"] "" "DetectedErrors"
set Texte [join $LesTrois "\n"]
return [AfficheVariable $Texte "" $Type]
}
proc MutationMTM {{Qui ""} {Quoi ""} {Ou ""}} {
global MutationMTM
if {$Qui==""} { set Qui "ListOf" ; set Quoi "ListOf" ; set Ou "All" }
if {[info exists MutationMTM($Qui,$Quoi,$Ou)]} { return $MutationMTM($Qui,$Quoi,$Ou) }
if {[info exists MutationMTM("EstCharge")]} {
if {$Qui=="PatientCode"} {
set Type $Quoi
set I $Ou
set lT [MutationMTM ListOf Possible Type]
set iT [lsearch $lT $Type]
set T [string index [lindex $lT $iT] 0]
if {$Type=="SmallDelIns"} { set T "I" }
set Imoins1 [expr $I - 1]
set P [format "%s%4.4d" $T $Imoins1]
return $P
}
if {$Ou=="" && [info exists MutationMTM($Qui,,$Quoi)]} { return $MutationMTM($Qui,,$Quoi) }
return ""
}
set MutationMTM("EstCharge") 1
set Rep "[HomeRipp]/GenoretWww/Collaboration/MutationsMTM"
set MutationMTM(ListOf,Possible,Type) [list Polymorphism MisSens NonSens SmallDelIns LargeDeletion SpliceSite]
foreach Type $MutationMTM(ListOf,Possible,Type) {
set F "$Rep/MutationsMTM-$Type.csv"
if {[info exists T]} { unset T }
LoadTxlWithRowsOfCells $F T -1 ";" "" "WholeLine"
foreach Clef [array names T] {
set MutationMTM($Clef,$Type) $T($Clef)
}
}
foreach Clef [array names MutationMTM] {
if {[regexp "^List" $Clef]} {
regsub -all "\," $Clef " " Clef
lappend MutationMTM(ListOf,ListOf,All) $Clef
}
}
lappend MutationMTM(ListOf,ListOf,All) "ListOf ListOf All"
return [MutationMTM $Qui $Quoi $Ou]
}
proc ExtractMutationFromRetinaHtml {{UrlOuFichier ""}} {
if {$UrlOuFichier==""} { set UrlOuFichier "http://www.retina-international.org/sci-news/rdsmut.htm" }
if {[regexp "^http" $UrlOuFichier]} {
set Texte [HttpGetTextFromUrl $UrlOuFichier]
} else {
set Texte [ContenuDuFichier $UrlOuFichier]
}
set Table [ValeurDeLaBalise "table" Texte]
Espionne [string range $Table 0 100]
if { ! [regexp -nocase "<th *>Phenotype</th>" $Table]} { set Table [ValeurDeLaBalise "table" Texte] }
Espionne [string range $Table 0 100]
set Entete [ValeurDeLaBalise "tr" Table]
set LesTetes {}
while 1 {
set Tete [ValeurDeLaBalise "th" Entete]
if {$Tete==""} { break }
regsub -all {\n} $Tete "" Tete
regsub -all {<[^>]+>} $Tete "" Tete
regsub -all {\&} $Tete " and " Tete
regsub -all { +} $Tete " " Tete
regsub -all " " $Tete "_" Tete
lappend LesTetes $Tete
Espionne "Tete $Tete"
}
set I 0
while 1 {
set Ligne [ValeurDeLaBalise "tr" Table]
if {$Ligne==""} { break }
foreach Tete $LesTetes {
set Valeur [ValeurDeLaBalise "td" Ligne]
while {[set B [ProchaineBalise Valeur "" "NePasRogner"]]!=""} {
set Valeur [ValeurDeLaBalise $B Valeur]
}
regsub -all "\n" $Valeur " " Valeur
regsub -all {<br[^>]*>} $Valeur " " Valeur
set T($I,$Tete) $Valeur
}
Espionne "$T($I,Phenotype) = $T($I,Mutation) + $T($I,Basechange) + $T($I,Nucleotide) + $T($I,Exon)"
incr I
}
exit
}
proc BelleVueMutation {H V Nom} {
if {$H=="MS2PH"} {
return [H_Href $V "http://pig-pbil.ibcp.fr/cgi-bin/magos/home"]
}
if {$H=="Mutation"} {
set P ""
scan $V "%s %s" B P
if {$B==""} { return $V }
set Access "${Nom}_${B}_${P}"
set Queue $Access
regsub -all {[>\?]} $Queue "-" Queue
set Clics ""
if { ! [regexp {[^p\.]} $P]} {
append Clics [H_Href $V "[WscopeScience]&FileMoi&nuctfaMut&$Queue" "target='_blank'"]
} else {
regsub "$B $P" $V "" Commentaire
append Clics [H_Href $B "[WscopeScience]&FileMoi&nuctfaMut&$Queue" "target='_blank'"]
append Clics " "
append Clics [H_Href $P "[WscopeScience]&FileMoi&prottfaMut&$Queue" "target='_blank'"]
append Clics " "
append Clics $Commentaire
}
append Clics " "
append Clics [H_Href "(See diff)" "[WscopeScience]&ShowMutationOnWeb&$Nom&$Queue" "target='_blank'"]
return $Clics
}
return [BelleVue $H $V $Nom]
}
proc ShowMutationOnWeb {Nom Queue} {
set FWT [RepertoireDuGenome]/nuctfa/$Nom
set FMu [RepertoireDuGenome]/nuctfaMut/$Queue
if {[FileAbsent $FWT]} { return "Sorry, the Wild Type file doesn't exist" }
if {[FileAbsent $FMu]} { return "Sorry, the mutation file doesn't exist" }
return [CompareADNDesFichiersTFA $FWT $FMu "SansAffichage"]
}
proc StoreSeqMut {Nom Alias SeqNuc B P F {Status ""}} {
set Access "${Nom}_${B}_${P}"
set Queue $Access
regsub -all {[\>\?]} $Queue "-" Queue
Espionne "Queue $Queue"
set Remarque ""
if {$Status=="ProtAnnounceWrong"} {
set Remarque "CAUTION : the protein code is not correct the sequence can be wrong"
}
if {$Status=="StopNotFound"} {
set Remarque "CAUTION : the stop codon was not found the sequence ends abnormally"
}
set Entete "$Access mutated sequence of $Alias $Remarque"
set NucTFA [SequenceFormatTFA $SeqNuc $Entete "nucbrut"]
set FichierN "[RepertoireDuGenome]/nuctfaMut/$Queue"
Sauve $NucTFA dans $FichierN
set SeqPro [SeqNucToSeqPro $SeqNuc]
set ProTFA [SequenceFormatTFA $SeqPro $Entete "protbrut"]
set FichierP "[RepertoireDuGenome]/prottfaMut/$Queue"
Sauve $ProTFA dans $FichierP
return $Queue
}
proc RetGeneMutation {{Quoi ""}} {
if {$Quoi=="LesHeaders"} { return [list "GscopeId" "GeneName" "MS2PH" "Mutation" "Family" "Other Allele Mutation"] }
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
foreach Mut [LesMutations $Nom [list "LCA:" "Mut:" "AGal:"]] {
set Famille ""
set Mutation $Mut
if { ! [regexp {^[cgp]\.} $Mut]} {
scan $Mut "%s" Famille
regsub {[^ ]+ } $Mut "" Mutation
}
lappend LesMutationsDeLaFamille($Famille) $Mutation
}
foreach Mut [LesMutations $Nom [list "LCA:" "Mut:" "AGal:"]] {
set OtherAlleleMutation ""
set Famille ""
set Mutation $Mut
if { ! [regexp {^[cgp]\.} $Mut]} {
scan $Mut "%s" Famille
regsub {[^ ]+ } $Mut "" Mutation
}
if {$Famille!="" && [info exists LesMutationsDeLaFamille($Famille)]} {
set M1 ""
set M2 ""
ScanLaListe $LesMutationsDeLaFamille($Famille) M1 M2
set OtherAlleleMutation $M1
if {$M2!="" && $M2!=$Mutation} { set OtherAlleleMutation $M2 }
}
if {$OtherAlleleMutation==$Mutation} {
set OtherAlleleMutation "same mutation on both alleles"
} else {
}
regsub "RG" $Nom "MS2PH" MS2PHId
set Ligne "$Nom;$Alias;$MS2PHId;$Mutation;$Famille;$OtherAlleleMutation"
lappend LesLignes $Ligne
}
}
return $LesLignes
}
proc RetGeneMutationOnWeb {} {
set LesHeaders [RetGeneMutation "LesHeaders"]
set NbHeaders [llength $LesHeaders]
set Titre "Gscope summary of mutations"
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
}
foreach Ligne [RetGeneMutation "GetList"] {
set LesValeurs [split $Ligne ";"]
set Nom [lindex $LesValeurs 0]
if { ! [EstUnPAB $Nom]} { continue }
foreach H $LesHeaders V $LesValeurs {
set Vue [BelleVueMutation $H $V $Nom]
lappend Liste $Vue
}
}
Html_TableFromList $Liste
Html_BodyToEnd
return [Html_Get "ZeroIt"]
}
proc CorrigeLesInfosLCA {} {
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set Inf [ExtraitInfo $Nom $Alias]
if {$Inf==""} { continue }
foreach M [split $Inf "/"] {
set M [string trim $M]
Espionne "\n$Nom"
set Fin $M
if {[regexp {P\.([A-Z])([0-9]+)([A-Z])} $M Match A P N]} {
set AAA [string totitle [UT $A]]
set NNN [string totitle [UT $N]]
if {$NNN=="Xxx"} { set NNN "X" }
set New "p.$AAA$P$NNN"
regsub $Match $M $New Fin
}
Espionne $Fin
InformeSansDemander $Nom "Mut: $Fin"
}
}
}
proc LesMutations {Nom LesCas} {
set LesMutations {}
foreach Cas $LesCas {
if {$Cas=="AGal:"} {
if {[Alias $Nom]!="RDH12"} { continue }
LConcat LesMutations [RDH12PatientAndMutation]
continue
}
set M [ExtraitInfo $Nom "$Cas"]
regsub -all { */ *} $M "/" M
LConcat LesMutations [split $M "/"]
}
return $LesMutations
}
proc LesLca Nom {
set L [ExtraitInfo $Nom "LCA:"]
regsub -all " / " $L "/" L
return [split $L "/"]
}
proc LesMut Nom {
set L [ExtraitInfo $Nom "Mut:"]
regsub -all " / " $L "/" L
return [split $L "/"]
}
proc VerifieLesInfosLca {{LesLcaEtOuMut ""} {Liste ""}} {
if {[EstUnPAB $Liste]} { set Liste [list $Liste] }
if {$Liste==""} { set Liste [ListeDesPABs] }
if {[OuiOuNon "Do I test all ?"]} {
set TestSingle 1
set TestDel 1
set TestIns 1
} else {
set TestSingle [OuiOuNon "Do I test singles?"]
set TestDel [OuiOuNon "Do I test del ?"]
set TestIns [OuiOuNon "Do I test ins ?"]
}
if {$LesLcaEtOuMut==""} {
set LesLcaEtOuMut [ChoixParmi [list "LCA:" "Mut:" "Gal:" "LCA: Mut: Gal:"]]
}
foreach Nom $Liste {
set Alias [Alias $Nom]
Espionne "$Nom $Alias"
set SeqNuc [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
set SeqNuc "n$SeqNuc"
set SeqPro [QueLaSequenceDuFichierTFA [GscopeFile $Nom "prottfa"]]
set SeqPro "x$SeqPro"
foreach LCA [LesMutations $Nom $LesLcaEtOuMut] {
Espionne $LCA
set F ""
set B ""
set P ""
scan $LCA "%s %s %s" F B P
if { ! [regexp {^[0-9_\*]+} $LCA F]} { set F "000" }
if { ! [regexp {c\.[^ $]+} $LCA B]} { set B "" }
if { ! [regexp {p\.[^ $]+} $LCA P]} { set P "" }
Espionne "F=$F B=$B P=$P"
if {[regexp {([A-Z])([0-9]+)([A-Z])} $P Match U1 pP U2]} {
FaireLire "I found an 1 letter code for $LCA"
set OldP $P
set AAA1 [string totitle [UT $U1]]
set AAA2 $U2
if {$U2!="X"} { set AAA2 [string totitle [UT $U2]] }
set P "p.$AAA1$pP$AAA2"
Espionne "F=$F B=$B P=$P renomme"
set LCA "$F $B $P it was_in_1_letter_code $OldP"
InformeSansDemander $Nom "Gal2: $B $P it was_in_1_letter_code $OldP"
} else {
InformeSansDemander $Nom "Gal2: $B $P"
}
regsub {c\.} $B "" Code
if { ! [regexp {^[0-9]+(\-?[0-9]+)?} $Code Match ]} { FaireLire "Bad code : $Code" }
set Fin ""
regsub {\-} $Match " " DF
scan $DF "%d %sd" Debut Fin
if {$Fin==""} { set Fin $Debut }
if {([regexp "del" $Code] || [regexp "ins" $Code]) && ($TestIns || $TestDel)} {
set Nouveau [StringSuivant "ins" dans $Code]
set PosP [expr ($Debut-1 +3)/3]
set PosF [expr $PosP*3]
set PosD [expr $PosF - 2]
set Codon [string range $SeqNuc $PosD $PosF]
set A [AAduCodon $Codon]
set AAA [string totitle [UT $A]]
Espionne "$Nom $LCA $Codon $AAA$PosP $P"
if { ! [regexp "p\.$AAA${PosP}" $P]} {
if {[OuiOuNon "for $Nom $LCA\n\
I didn't found p.$AAA${PosP}fs in $P\n\
Codon $Codon $A $AAA\n\
Do I inform $Nom"] } {
Informe $Nom
}
}
set SeqNucMut "[string range $SeqNuc 0 [expr $Debut - 1]]$Nouveau[string range $SeqNuc [expr $Fin + 1] end]"
set Long [string length $SeqNucMut]
set FoundStop 0
while 1 {
if {$PosF>=$Long} { break }
set Codon [string range $SeqNucMut $PosD $PosF]
if {[CodonStopPossible $Codon]} { set FoundStop 1 ; break }
incr PosD 3
incr PosF 3
}
if {$FoundStop} {
set PosS [expr $PosF/3]
set PosX [StringSuivant "X" dans $LCA]
regsub { .*} $PosX "" PosX
if {$PosX<$PosP} { FaireLire "Relative PosX in $LCA" ; set PosX [expr $PosP + $PosX]}
if {$PosX==$PosS} {
Espionne "$LCA $PosS $Codon $AAA$PosP $P"
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F
} else {
if {[OuiOuNon "for $Nom $LCA \n\
The annouced Stop position $PosX is not what I found $PosS\nDo I show ?"]} {
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "$PosX $PosS Mutant of $Nom $LCA"
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "$PosX $PosS Wildtype of $Nom $LCA"
Espionne "$LCA $Codon $AAA$PosP $P"
Informe $Nom "LCA: $LCA but should be p.$AAA${PosP}fsX$PosS"
}
}
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F "ProtAnnounceWrong"
} else {
if {[OuiOuNon "For $Nom $LCA I didn't find the stop. Do I show ?"]} {
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "Wildtype of $Nom $LCA"
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "Mutant of $Nom $LCA"
AfficheVariable "$LCA $Codon $AAA$PosP $P" "AvecRetour"
}
set SeqNucMutOK "[string range $SeqNucMut 1 end]"
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F "StopNotFound"
}
continue
}
if {([regexp "ins" $Code] || [regexp "dup" $Code]) && $TestIns} {
if {[regexp "dup" $Code]} {
set DD ""
set FD ""
set DupAnnonce ""
if { ! [regexp {([0-9]+)\-([0-9]+)dup([A-Z]+)?} $Code Match DD FD DupAnnonce]} {
FaireLire "the dup is incorrect. I'll cancel $LCA" ; continue
}
set DupSequence [string range $SeqNuc $DD $FD]
if {$DupAnnonce!="" && ! [string equal -nocase $DupAnnonce $DupSequence]} {
FaireLire "The announced dup $DupAnnonce is not $DupSequence"
}
set Debut $FD
set Fin [expr $Debut + 1]
set Code "$Debut-${Fin}ins[string toupper $DupSequence]"
Espionne "test dup : $LCA $Code"
} else {
Espionne "test ins : $LCA $Code"
}
set Nouveau [StringSuivant "ins" dans $Code]
set PosP [expr ($Debut+3)/3]
set PosF [expr $PosP*3]
set PosD [expr $PosF - 2]
set Codon [string range $SeqNuc $PosD $PosF]
set A [AAduCodon $Codon]
set AAA [string totitle [UT $A]]
Espionne "$Nom $LCA $Codon $AAA$PosP $P"
if { ! [regexp "p\.$AAA${PosP}fs" $P]} {
if {[OuiOuNon "for $Nom $LCA\n\
I didn't found p.$AAA${PosP}fs in $P\n\
Codon $Codon $A $AAA\n\
Do I inform $Nom"] } {
Informe $Nom
}
}
set SeqNucMut "[string range $SeqNuc 0 $Debut]$Nouveau[string range $SeqNuc $Fin end]"
set Long [string length $SeqNucMut]
set FoundStop 0
while 1 {
if {$PosF>=$Long} { break }
set Codon [string range $SeqNucMut $PosD $PosF]
if {[CodonStopPossible $Codon]} { set FoundStop 1 ; break }
incr PosD 3
incr PosF 3
}
if {$FoundStop} {
set PosS [expr $PosF/3]
set PosX [StringSuivant "X" dans $LCA]
regsub { .*} $PosX "" PosX
if {$PosX<$PosP} { FaireLire "Relative PosX in $LCA" ; set PosX [expr $PosP + $PosX]}
if {$PosX==$PosS} {
Espionne "$LCA $PosS $Codon $AAA$PosP $P"
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F
} else {
if {[OuiOuNon "for $Nom $LCA \n\
The annouced Stop position $PosX is not what I found $PosS\nDo I show ?"]} {
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "$PosX $PosS Mutant of $Nom $LCA"
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "$PosX $PosS Wildtype of $Nom $LCA"
Espionne "$LCA $Codon $AAA$PosP $P"
Informe $Nom "LCA: $LCA but should be p.$AAA${PosP}fsX$PosS"
}
}
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F "ProtAnnounceWrong"
} else {
if {[OuiOuNon "For $Nom $LCA I didn't find the stop. Do I show ?"]} {
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "Wildtype of $Nom $LCA"
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "Mutant of $Nom $LCA"
AfficheVariable "$LCA $Codon $AAA$PosP $P" "AvecRetour"
}
set SeqNucMutOK "[string range $SeqNucMut 1 end]"
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F "StopNotFound"
}
continue
}
if {[regexp "del" $Code] && $TestDel} {
set Annonce [StringSuivant "del" dans $Code]
set Ancien [string range $SeqNuc $Debut $Fin]
if {$Annonce!="" && ! [string equal -nocase $Annonce $Ancien]} {
FaireLire "For $Nom $LCA the announced sequence is \n$Annonce\nthe ture sequence is \n$Ancien"
}
set PosP [expr ($Debut+2)/3]
set PosF [expr $PosP*3]
set PosD [expr $PosF - 2]
set Codon [string range $SeqNuc $PosD $PosF]
set A [AAduCodon $Codon]
set AAA [string totitle [UT $A]]
if { ! [regexp "p\.$AAA${PosP}fs" $P]} {
if {[OuiOuNon "for $Nom $LCA\n\
I didn't found p.$AAA${PosP}fs in $P\n\
Codon $Codon $A $AAA\n\
Do I inform $Nom"]} {
Informe $Nom
}
}
set SeqNucMut [string replace $SeqNuc $Debut $Fin ""]
set Long [string length $SeqNucMut]
set FoundStop 0
while 1 {
if {$PosF>=$Long} { break }
set Codon [string range $SeqNucMut $PosD $PosF]
if {[CodonStopPossible $Codon]} { set FoundStop 1 ; break }
incr PosD 3
incr PosF 3
}
if {$FoundStop} {
set PosS [expr $PosF/3]
set PosX [StringSuivant "X" dans $LCA]
regsub { .*} $PosX "" PosX
if {$PosX<$PosP} { FaireLire "Relative PosX in $LCA" ; set PosX [expr $PosP + $PosX]}
if {$PosX==$PosS} {
Espionne "$LCA $PosS $Codon $AAA$PosP $P"
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F
} else {
if {[OuiOuNon "for $Nom $LCA \n\
The annouced Stop position $PosX is not what I found $PosS\nDo I show ?"]} {
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "$PosX $PosS Mutant of $Nom $LCA"
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "$PosX $PosS Wildtype of $Nom $LCA"
Espionne "$LCA $Codon $AAA$PosP $P"
Informe $Nom "LCA: $LCA but should be p.$AAA${PosP}fsX$PosS"
}
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F "ProtAnnounceWrong"
}
} else {
if {[OuiOuNon "For $Nom $LCA I didn't find the stop. Do I show ?"]} {
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "Wildtype of $Nom $LCA"
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "Mutant of $Nom $LCA"
AfficheVariable "$LCA $Codon $AAA$PosP $P" "AvecRetour"
}
set SeqNucMutOK [string range $SeqNucMut 1 end]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F "StopNotFound"
}
continue
}
if {$TestSingle} {
if {$B=="" && $P!=""} {
if {[regexp {p.([A-Z][a-z][a-z])([0-9]+)([A-Z][a-z][a-z]|X)} $P Match AncienAAA PosiP NouveauAAA]} {
set AncienA [UT $AncienAAA]
if {$NouveauAAA=="X"} {
set NouveauA "X"
} else {
set NouveauA [UT $NouveauAAA]
}
set AAADeSeq [string index $SeqPro $PosiP]
if {$AncienA!=$AAADeSeq} {
FaireLire "$P id $AncienAAA and should be $AAADeSeq"
continue
} else {
set PosiNF [expr $PosiP * 3]
set PosiND [expr $PosiNF - 2]
set CodonAncien [string range $SeqNuc $PosiND $PosiNF]
set LesMutationsPossibles [LesCodesGenetiques $NouveauA]
set L [list "$CodonAncien as to be mutate to what ? Please choose one." ]
LConcat L $LesMutationsPossibles
set LesMutationsChoix [ChoixParmi $L]
if {$Choix!=""} {
set PosiN $PosiNF
foreach a [split $CodonAncien ""] n [split $Choix ""] {
set a [string toupper $a]
set n [string toupper $n]
if {$n!=$a} { break }
incr PosiN
}
set BonB "c.${PosiN}$a>$n"
set BonneMut "$BonB $P rR a invente $BonB"
Informe $Nom "Mut: $BonneMut"
}
continue
}
}
}
set Annonce [StringSuivant $Match dans $Code]
regsub ">.*" $Annonce "" Annonce
set Nouveau [StringSuivant ">" dans $Code]
set Ancien [string range $SeqNuc $Debut $Fin]
Espionne "$B $Match $Debut $Fin $Annonce $Ancien $Nouveau"
if {$Annonce==""} {
if {[OuiOuNon "For $Nom $LCA\n\
I didn't found the sequence to replace\n\
Do I inform $Nom"]} {
Informe $Nom
}
continue
}
if { ! [string equal -nocase $Annonce $Ancien]} {
if {[OuiOuNon "For $Nom $LCA the announced sequence $Annonce is not what i found $Ancien\n\
Do I inform $Nom"]} {
Informe $Nom
}
if {[OuiOuNon "Do I skipp $Nom $LCA"]} { continue }
}
set PosP [expr ($Debut+2)/3]
set PosF [expr $PosP*3]
set PosD [expr $PosF - 2]
set Codon [string range $SeqNuc $PosD $PosF]
set A [AAduCodon $Codon]
set AAA [string totitle [UT $A]]
Espionne "$LCA $Codon $AAA$PosP $P"
if { ! [regexp "p\.$AAA${PosP}" $P]} {
if {[OuiOuNon "for $Nom $LCA\n\
I didn't found p.$AAA${PosP}fs in $P\n\
Codon $Codon $A $AAA\n\
Do I inform $Nom"]} {
Informe $Nom
}
}
set NouveauAnnonce [StringSuivant "p\.$AAA${PosP}" dans $LCA]
regsub { .*} $NouveauAnnonce "" NouveauAnnonce
set SeqNucMut [string replace $SeqNuc $Debut $Fin $Nouveau]
set Long [string length $SeqNucMut]
set FoundStop 0
Espionne "$LCA $Code"
set TestePremier 1
while 1 {
if {$PosF>=$Long} { break }
set Codon [string range $SeqNucMut $PosD $PosF]
if {$TestePremier} {
set NouveauM [AAduCodon $Codon]
set NouveauMut [string totitle [UT [AAduCodon $Codon]]]
if {$NouveauMut=="Xxx"} { set NouveauMut "X" }
if {$NouveauMut!=$NouveauAnnonce} {
if {[OuiOuNon "Do I show $LCA $Codon $NouveauMut==$NouveauAnnonce"]} {
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "Wildtype of $Nom $LCA"
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "Mutant of $Nom $LCA should be $NouveauMut $NouveauM"
Informe $Nom
}
}
}
set TestePremier 0
if {[CodonStopPossible $Codon]} { set FoundStop 1 ; break }
incr PosD 3
incr PosF 3
}
if {$FoundStop} {
set PosS [expr $PosF/3]
set PosX [StringSuivant "fsX" dans $LCA]
regsub { .*} $PosX "" PosX
if {$PosX!=""} {
if {$PosX==$PosS} {
Espionne "$LCA $PosS $Codon $AAA$PosP $P"
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F
} else {
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "$PosX $PosS Mutant of $Nom $LCA"
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "$PosX $PosS Wildtype of $Nom $LCA"
Espionne "$LCA $Codon $AAA$PosP $P"
Informe $Nom "LCA: $LCA but should be p.$AAA${PosP}fsX$PosS"
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F "ProtAnnounceWrong"
}
} else {
set SeqNucMutOK [string range $SeqNucMut 1 $PosF]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F
}
} else {
if {[regexp "fs" $LCA]} {
if {[OuiOuNon "For $Nom $LCA I didn't find the stop. Do I show ?"]} {
VoisinADN [string range $SeqNuc 1 end] "" "" "" "" "Wildtype of $Nom $LCA"
VoisinADN [string range $SeqNucMut 1 end] "" "" "" "" "Mutant of $Nom $LCA"
AfficheVariable "$LCA $Codon $AAA$PosP $P" "AvecRetour"
}
}
set SeqNucMutOK [string range $SeqNucMut 1 end]
StoreSeqMut $Nom $Alias $SeqNucMutOK $B $P $F "StopNotFound"
}
continue
}
}
}
return
}
proc TesteLesMutationsLCA {} {
Delimite
set LesHeaders [LCA ListOf Headers]
set LesHs [LIndexes $LesHeaders 2 3 5 6]
foreach TN [LCA ListOf Tables] {
set Gene [LCA $TN Gene]
set Nom [NomDuAlias $Gene]
VoisinADN $Nom "nuctfa"
set SeqNuc [QueLaSequenceDuAlias $Gene "nuctfa"]
if {$SeqNuc==""} { continue }
set SeqNuc "n$SeqNuc"
foreach Family [LCA $TN Families] {
foreach {H HP H2 HP2} $LesHs {
set B [string trim [LCA $Family $H] " ."]
set P [string trim [LCA $Family $HP] " ."]
set B2 [string trim [LCA $Family $H2] " ."]
set P2 [string trim [LCA $Family $HP2] " ."]
set TBP "$TN $Gene $B $P"
set TBP2 "$TN $Gene $B2 $P2"
lappend LesTBP $TBP $TBP2
set BPBP [lsort [list "$B $P" "$B2 $P2"]]
ScanLaListe $BPBP BP BP2
scan $BP "%s %s" B P
scan $BP2 "%s %s" B2 P2
set TBPBP2 "$TN $B $P $B2 $P2"
lappend LesFamillesDe($TBPBP2) $Family
lappend LesTBPBP2 $TBPBP2
if {[info exists AutreDe($TN,$B)] && $AutreDe($TN,$B)!=$P} { FaireLire "$Family $TN $B \n$AutreDe($TN,$B)\n$P" }
set AutreDe($TN,$B) $P
}
}
foreach Family [LCA $TN Families] {
foreach {H HP} $LesHs {
set V [string trim [LCA $Family $H] " ."]
regsub -all "_" $V "-" V
regsub -all {[^0-9]} $V " " VPourPos
set Pos ""
scan $VPourPos "%d" Pos
if {$Pos==""} {
set Info [string trim "LCA_error: $Family $V [LCA $Family $HP]"]
regsub -all {[\:\*\+\-\?]} $Info {\\&} InfoX
Espionne $InfoX
if { ! [regexp $InfoX [ExtraitInfo $Nom]]} {
Informe $Nom $Info
}
continue
}
set O [string index $SeqNuc $Pos]
set W ""
regsub { *c *\.} $V "" BonV
if {[regexp {^[0-9]+del} $BonV Match]} {
regsub $Match $V "" W
regsub "c\." $W "" W
} elseif {[regexp {^[0-9]+\-[0-9]+del} $BonV Match]} {
regsub $Match $BonV "" W
regsub -all {[^0-9]} $Match " " P1P2
set Pos1 9999
set Pos2 -1
scan $P1P2 "%d %d" Pos1 Pos2
set O [string range "$SeqNuc" $Pos1 $Pos2]
} else {
regsub {c *\. *[0-9]+} $V "" W
regsub {>.*} $W "" W
}
if {[string equal -nocase $O $W]} {
set Info [string trim "LCA: $Family $V [LCA $Family $HP]"]
regsub -all {[\:\*\+\-\?]} $Info {\\&} InfoX
Espionne $InfoX
if { ! [regexp $InfoX [ExtraitInfo $Nom]]} {
Informe $Nom $Info
}
continue
}
set Info [string trim "LCA_pb: $Family $V [LCA $Family $HP] no corespondance between $O and $W"]
regsub -all {[\:\*\+\-\?]} $Info {\\&} InfoX
Espionne $InfoX
if { ! [regexp $InfoX [ExtraitInfo $Nom]]} {
Informe $Nom $Info
}
Espionne "$O $W \t$Gene $Family $V"
}
}
}
set Avant [llength $LesTBPBP2]
set LesTBPBP2 [lsort -u $LesTBPBP2]
EspionneL $LesTBPBP2
set Apres [llength $LesTBPBP2]
Espionne "$Avant $Apres"
foreach TBPBP2 $LesTBPBP2 {
Espionne ""
Espionne $TBPBP2
Espionne $LesFamillesDe($TBPBP2)
}
set LesTBP [lsort -unique $LesTBP]
EspionneL $LesTBP
return
}
proc CreateSqlForLCA {} {
set SqlTable "kaplan"
foreach TN [LCA ListOf Tables] {
set Gene [LCA $TN Gene]
set Sql "insert into $SqlTable.gene (name,description) values \
('$Gene','This gene is the reference of Table $TN: mutations in patients affected with LCA');"
Espionne $Sql
}
exit
}
proc RDH12CodificationFromGal {QuiB QuiP Quoi} {
global RDH12CodificationFromGal
regsub -all {\+} $QuiB ">" QuiB
set Qui "$QuiB,$QuiP"
if {[info exists RDH12CodificationFromGal($Qui,$Quoi)]} { return $RDH12CodificationFromGal($Qui,$Quoi) }
if {[info exists RDH12CodificationFromGal("EstCharge")]} { return "$QuiB $QuiP" }
set RDH12CodificationFromGal("EstCharge") 1
foreach Ligne [LesMutations [NomDuAlias "RDH12"] "Gal:"] {
set OldB ""
set OldP ""
Espionne $Ligne
scan $Ligne "%s %s %s %s %s %s" B P it was OldB OldP
if {[regexp "^p" $OldB]} { set OldP $OldB ; set OldB "" }
if {$OldB==""} { set OldB $B }
if {$OldP==""} { set OldP $P }
set RDH12CodificationFromGal($B,$P,Old) "$OldB $OldP"
set RDH12CodificationFromGal($OldB,$OldP,New) "$B $P"
set RDH12CodificationFromGal($B,$P,New) "$B $P"
set RDH12CodificationFromGal($OldB,$OldP,Old) "$OldB $OldP"
set RDH12CodificationFromGal($B,$P,Line) $Ligne
set RDH12CodificationFromGal($OldB,$OldP,Line) $Ligne
}
return [RDH12CodificationFromGal $QuiB $QuiP $Quoi]
}
proc InformeRDH12 {} {
set Nom [NomDuAlias "RDH12"]
foreach BP [RDH12 ListOf Mutations] {
InformeSansDemander $Nom "GAL: $BP"
}
}
proc RDH12PatientAndMutation {} {
foreach Patient [RDH12 ListOf Patients] {
set NdMut [RDH12 $Patient "NdMut"]
set LesMutationsDuPatient $NdMut
lappend LesMutationsDuPatient [RDH12 $Patient "PaterMut"]
lappend LesMutationsDuPatient [RDH12 $Patient "MaterMut"]
foreach Mut $LesMutationsDuPatient {
scan $Mut "%s %s" B P
set Ligne [RDH12CodificationFromGal $B $P Line]
set FBP "AG-$Patient $Ligne"
lappend RDH12PatientAndMutation $FBP
}
}
return $RDH12PatientAndMutation
}
proc RDH12 {{Qui ""} {Quoi ""}} {
global RDH12
Wup "Ici on cree des ordres sql de creation des tables mais ce n'est pas en core utilise"
if {$Qui==""} { set Qui "LesOrdres" ; set Quoi "SQL" }
if {[info exists RDH12($Qui,$Quoi)]} { return $RDH12($Qui,$Quoi) }
if {[info exists RDH12("EstCharge")]} { return "" }
set RDH12("EstCharge") 1
set LesValeurs [LesLignesDuFichier "[HomeRipp]/GenoretBeaufort/Recu/DeGal/RDH12-EVI-Genoret-1.txt"]
set T [expr [llength $LesValeurs]/3 -1]
set I -1
set iSQL 0
foreach CLu [lrange $LesValeurs [incr I] [incr I $T]] \
PLu [lrange $LesValeurs [incr I] [incr I $T]] \
SLu [lrange $LesValeurs [incr I] [incr I $T]] {
Espionne "\n$CLu $PLu $SLu"
regsub -all "_" $CLu "-" CLu
regsub -all -nocase {[^a-z0-9]} $SLu " " S
set A1 "" ; set A2 ""
scan $S "%s %s %s" Id A1 A2
set C $CLu
set P $PLu
if {$C==""} { set C $OldC }
if {$P==""} { set P $OldP }
set OldC $C
set OldP $P
set Ap "x" ; set Am "x" ; set And "x"
if {$A1=="nd" || $A2=="nd" } { set And "nd" }
if {$A1=="p" || $A2=="p" } { set Ap "p" }
if {$A1=="m" || $A2=="m" } { set Am "m" }
if {$Ap=="p"} {
set RDH12($Id,PaterMut) "$C $P"
set CreateP [incr iSQL]
lappend LesOrdresSql "create $CreateP RDH12 $C $P $Id p"
if { ! [info exists DejaVuPaterMut($C,$P)]} {
lappend RDH12(ListOf,PaterMut) "$C $P"
set DejaVuPaterMut($C,$P) 1
}
}
if {$Am=="m"} {
set RDH12($Id,MaterMut) "$C $P"
set CreateM [incr iSQL]
lappend LesOrdresSql "create $CreateM RDH12 $C $P $Id m"
if { ! [info exists DejaVuMaterMut($C,$P)]} {
lappend RDH12(ListOf,MaterMut) "$C $P"
set DejaVuMaterMut($C,$P) 1
}
}
if {$And=="nd"} {
lappend RDH12($Id,NdMut) "$C $P"
set CreateND [incr iSQL]
lappend LesOrdresSql "create $CreateND RDH12 $C $P $Id nd"
if { ! [info exists DejaVuNdMut($C,$P)]} {
lappend RDH12(ListOf,NdMut) "$C $P"
set DejaVuNdMut($C,$P) 1
}
}
if { ! [info exists DejaVuMut($C,$P)]} {
lappend RDH12(ListOf,Mutations) "$C $P"
set DejaVuMut($C,$P) 1
}
if {$Ap=="p" && $Am=="m"} {
set Link [incr iSQL]
lappend LesOrdresSql "link $Link $CreateP $CreateM RDH12 $C $P $Id p m"
set Link [incr iSQL]
lappend LesOrdresSql "link $Link $CreateM $CreateP RDH12 $C $P $Id m p"
}
lappend RDH12(ListOf,Patients) $Id
}
set RDH12(ListOf,Mutations) [lsort -unique $RDH12(ListOf,Mutations)]
set RDH12(ListOf,Mutations) [lsort -command DenicheEtCompareLesIntegersEnDebut $RDH12(ListOf,Mutations)]
set RDH12(ListOf,Patients) [lsort -unique $RDH12(ListOf,Patients)]
set RDH12(LesOrdres,SQL) $LesOrdresSql
return [RDH12 $Qui $Quoi]
}
proc GoodCodeForPredictedChange {V {WithoutReferences ""}} {
if {$WithoutReferences==""} { set WithoutReferences "WithoutReferences" }
set WithoutReferences [string equal -nocase $WithoutReferences "WithoutReferences"]
set V [string trim $V "."]
set OldV $V
if {[regexp {[0-9](\,[0-9])+$} $V Match]} {
regsub -all "\," $Match " " StrMatch
scan $StrMatch "%d %d" A B
set Bon $Match
if {$A>$B} {
regsub {^[0-9]} $Match "" Match
regsub {\,} $Match "" Bon
}
regsub -all "\," $Match "\\," ExMatch
regsub $ExMatch $V "^$Bon" V
if {$WithoutReferences} { regsub {\^.*$} $V "" V }
return $V
}
if {[regexp {\,([0-9]+)$} $V Match P2]} {
set P1 [expr $P2-1]
regsub "$P1\,$P2$" $V "^$P1,$P2" V
if {$WithoutReferences} { regsub {\^.*$} $V "" V }
return $V
}
set X [expr [string last "X" $V] + 1]
set PE [string range $V $X end]
regsub -all {[^0-9]} $V " " VI
set A "Salut"
set B "Coucou"
scan $VI "%d %d" A B
if {$A!="Salut" && $B==$PE } {
for {set I [expr [string length $A] - 1]} { $I < [string length $B]} { incr I } {
set P [string range $B 0 $I]
set Z [expr $X + $I]
set R [expr (1.0*$P)/$A]
if {[expr $Z>=[string length $V]-1]} { break }
if {0.8 < $R && $R < 1.2} {
set V "[string range $V 0 $Z]^[string range $V [incr Z] end]"
if {$WithoutReferences} { regsub {\^.*$} $V "" V }
return $V
}
}
if {$A>$B} { regsub "X" $V "X^" V }
if {$WithoutReferences} { regsub {\^.*$} $V "" V }
return $V
}
if {[regexp {[A-Z][a-z]+([0-9]+)$} $V Match N]} { regsub "$N$" $V "^$N" V }
if {$WithoutReferences} { regsub {\^.*$} $V "" V }
return $V
}
proc LCA {{Qui ""} {Quoi ""}} {
global LCA
if {$Qui==""} { set Qui "ListOf" ; set Quoi "Tables" }
if {$Quoi==""} {
set Quoi "Values"
}
if {[info exists LCA($Qui,$Quoi)]} { return $LCA($Qui,$Quoi) }
if {[info exists LCA("EstCharge")]} { return "" }
set LCA("EstCharge") 1
foreach Ligne [LesLignesDuFichier "[HomeRipp]/GenoretBeaufort/Recu/DeLorentz/K2.csv"] {
if { ! [regexp ";" $Ligne]} {continue}
if {[regexp {^;;;Table} $Ligne]} {
set Table $Ligne
regsub -all ";" $Table "" Table
regsub { +\:} $Table ":" Table
if {[regexp {Table [0-9][A-Z] } $Table]} { regsub {Table [0-9][A-Z]} $Table "&:" Table }
set TN [StringApres "Table " dans $Table]
regsub "\:" $TN "" TN
regsub -all " " $TN "_" TN
lappend LCA(ListOf,Tables) $TN
set Gene [StringApres ":" dans $Table]
lappend LCA(ListOf,Genes) $Gene
set LCA($TN,Gene) $Gene
set LCA($TN,Families) $LCA(Current,Families)
foreach Family $LCA(Current,Families) {
set LCA($TN,$Family) $LCA(Current,$Family)
foreach H $LesHeaders V $LCA(Current,$Family) {
if {$H!="Family"} { regsub -all " " $V "" V }
if {[regexp "Predicted_Change" $H]} { set V [GoodCodeForPredictedChange $V] }
set LCA($Family,$H) $V
}
}
set LCA(Current,Families) {}
continue
}
if {[regexp "^Family" $Ligne]} {
if {[info exists LesHeaders]} { continue }
regsub -all " " $Ligne "_" Ligne
set LesHeaders {}
set Allele 1
foreach H [split $Ligne ";"] {
if {$H=="Family"} { lappend LesHeaders $H ; continue }
if {[info exists DejaVu(${H}_1)]} { set Allele 2 }
append H "_$Allele"
set DejaVu($H) 1
lappend LesHeaders $H
}
set LCA(ListOf,Headers) $LesHeaders
continue
}
if {[regexp {^;} $Ligne]} { continue }
set LesMots [split $Ligne ";"]
set Family [lindex $LesMots 0]
regsub -all " " $Family "_" Family
lappend LCA(Current,Families) $Family
set LCA(Current,$Family) $LesMots
set LCA($Family,Values) $LesMots
lappend LCA(ListOf,Families) $Family
}
return [LCA $Qui $Quoi]
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.