#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 {\&amp;}  $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 "&nbsp;&nbsp;"
	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]
}