#rR gscope_misynpat.tcl 

#rR Attention j'ai mis un FichierMemo dans MSP
#rR Penser à le mettre à jour si misynpat.sql est mis à jour     A FAIRE !!!!!!!!!!!!!!!!!!!!!! 
#rR Il faudrait aussi changer MSPFroMac pour ne pas interroger les Macsim à chaque fois 
#rR On peut même imaginer de supprimer le CafeDesSciences ...
#rR 2017/04/25  Raymond

proc VerifieAccession {} {
    set LesOk {}
    set LesKo {}
    set LesNe {}
    foreach Access [MSP Syn ListOf Accession] {
	set AC [GeneQuid UniProt $Access AC]
	if {$AC==""} {
	    Espionne "je ne trouve pas $Access"
	    lappend LesKo $Access
	    continue
	}
	if { ! [regexp -nocase $Access $AC]} {
	    Espionne "GeneQuid rend $AC pour $Access"
	    lappend LesNe $Access
	    continue
	}
	lappend LesOk $Access
	Espionne "$Access est ok"
    }
    return [list Ok $LesOk Ne $LesNe Ko $LesKo] 
}

proc VerifiePubmefInfoAFAIRE {} {
    #rR 20210419 Il se peut que les info stockées ne soient pas bonnes
    CanalSql [ConnInfoForDatabase MiSynPat]
    set LesPkPmid [SqlExec "select pk_biblio,pmid from biblio" "GetList"]
    #EspionneL $LesPkPmid
    set LesFaux {}
    foreach {Pk Pmid} $LesPkPmid {
	if {[info exists DejaVu($Pmid)]} {
	    Espionne "$DejaVu($Pmid) $Pk"
	    if {[SqlExec "select pk_biblio,pk_synthetase from ln_biblio_synthetase where pk_biblio='$Pk'"]!={}} {
		FaireLire "Oups $Pk existe dans ln_biblio_synthetase"
	    }
	    lappend LesTrop $Pk
	}
	lappend DejaVu($Pmid) $Pk
    }
    
}

proc EnleveDoublonsDansMisynpat {} {
    #rR 20210405 je ne sais pas pourquoi certaines entrées étaient en doublon !?
    CanalSql [ConnInfoForDatabase MiSynPat]
    set LesPkPmid [SqlExec "select pk_biblio,pmid from biblio" "GetList"]
    #EspionneL $LesPkPmid
    set LesTrop {}
    foreach {Pk Pmid} $LesPkPmid {
	if {[info exists DejaVu($Pmid)]} {
	    Espionne "$DejaVu($Pmid) $Pk"
	    if {[SqlExec "select pk_biblio,pk_synthetase from ln_biblio_synthetase where pk_biblio='$Pk'"]!={}} {
		FaireLire "Oups $Pk existe dans ln_biblio_synthetase"
	    }
	    lappend LesTrop $Pk
	}
	lappend DejaVu($Pmid) $Pk
    }
    Espionne Voici les doublons : $LesTrop
    foreach Pk $LesTrop {
	Espionne $Pk
	if { ! [OuiOuNonMemo "J'efface les doublons"]} { continue }
	SqlExec "delete from biblio where pk_biblio='$Pk'"
    }
    return "Bravo"
}

proc ReplaceSequenceInAlignment {FastaToInsert AccessionToRemove {OutputFile ""}} {
    global TAddS

    if {[regexp "\n" $FastaToInsert]} {
	set FastaToInsert [Sauve $FastaToInsert] dans "[TmpFile].tfa"
    }

    if {$OutputFile==""} { set OutputFile "New.xml" }

    set TAdds(KeepClus) 1
    set TAddS(File) $FastaToInsert
    set TAddS(Position) "afterseq"
    set TAddS(seqInsert) $AccessionToRemove
    set TAddS(Align) 1
    
    AjouteSeqs

    SauveLAlignement "XML" $OutputFile

    return $OutputFile
}

proc CreateProttfaDuSite {} {
    set LesNouveaux {}
    foreach Nom [ListeDesPABs] {
	set FicMsp [GscopeFile $Nom prottfaDuSite]
	set A [MSP Syn $Nom A]
	set S [MSP Syn $Nom SYSTEM]
	set HuMi [MSP Syn $A MonAccess]
	Espionne
	Espionne "$Nom $A $HuMi"
	set Accession           [AccessionDuMacsimXml $HuMi]
	set AccessionVertebrata [AccessionDuMacsimXml $HuMi "/home/ripp/msp/data/alignments/Vertebrata/macsimXmlPoch20170602/${A}mito_Homo.sapi_Poch.xml"]
	if {$Accession!=$AccessionVertebrata} { Espionne "$Nom $Accession $AccessionVertebrata ***********************************" }
	set SeqGap [TabSFOnDisk $HuMi seq]
	regsub -all -nocase {[^A-Z]} $SeqGap "" Seq
	set SeqMsp [QueLaSequenceDuTFA $FicMsp]
	if { ! [string equal $SeqMsp $Seq]} {
	    Espionne [string range $SeqMsp 0 80]
	    Espionne [string range $Seq    0 80]
	}
	set EnteteMsp [EnteteDuFichierTFA $FicMsp]
	set Entete $EnteteMsp
	regsub {synthetase [^ ]+$} $Entete "synthetase $Accession" Entete
	if {[regexp {synthetase$} $Entete]} { append Entete " $Accession" }
	if { ! [string equal $EnteteMsp $Entete]} {
	    Espionne $EnteteMsp
	    Espionne $Entete
	}
	set TFA [SequenceFormatTFA $Seq $Entete "protbrut"]
	Espionne $TFA
	set FicDuSite [GscopeFile $Nom prottfaDuSite]
	if {[OuiOuNonMemo "Je fais les mises à jour des tfa ? "]} { lappend LesNouveaux [Sauve $TFA dans $FicDuSite] }
    }
    return $LesNouveaux
}

proc AccessionDuMacsimXml {Name {FichierXml ""}} {
    if {$FichierXml==""} { set FichierXml "/home/ripp/msp/data/alignments/[string index $Name 0]_WithModules.xml" }
    if {[regexp "<seq-name>$Name</seq-name>.+?<seq-info>.+?<accession>(.+?)</accession>" [ContenuDuFichier $FichierXml] Match Accession]} { return $Accession }
    regsub mito $Name cyto Name
    if {[regexp "<seq-name>$Name</seq-name>.+?<seq-info>.+?<accession>(.+?)</accession>" [ContenuDuFichier $FichierXml] Match Accession]} { return $Accession }
    return ""
}

proc CreateLinksToStructures {} {
    NousAllonsAuBoulot "[RepertoireDuGenome]/structure"
    set LesLIens {}
    foreach Nom [ListeDesPABs] {
	set System [string tolower [ExtraitInfo $Nom "System:"]]
	set Cible "/home/ripp/msp/data/structures/$System"
	exec ln -sf $Cible $Nom
	Espionne $Cible
	lappend LesLiens "$Nom $Cible"
    }
    OnRevientDuBoulot
}

proc TabSFOnDisk {{Qui ""} {Quoi ""} {ReCreate ""}} {

    global TabSFOnDisk Sequences

    set ReCreate [string equal -nocase $ReCreate "ReCreate"]
    if {$ReCreate} {
	if {[info exists TabSFOnDisk]} { unset TabSFOnDisk }
    }
    if {[info exists TabSFOnDisk($Qui,$Quoi)]}  { return $TabSFOnDisk($Qui,$Quoi) }
    if {$Quoi=="" && [info exists TabSFOnDisk($Qui)]}  { return $TabSFOnDisk($Qui) }
    if {[info exists TabSFOnDisk("EstCharge")]} { return "" }
    set TabSFOnDisk("EstCharge") 1

    set FichierTabSFOnDisk "[MiSynPatDir]/TabSFOnDisk.txt"
    if { ! $ReCreate && [FileExists $FichierTabSFOnDisk]} {
	array set TabSFOnDisk [ContenuDuFichier $FichierTabSFOnDisk]
	set TabSFOnDisk("EstCharge") 1
	foreach humi $TabSFOnDisk(ListOf,humi) {
	    set ::Sequence($humi) $TabSFOnDisk($humi,seq)
	}
	return [TabSFOnDisk $Qui $Quoi]
    }
    package require TclOO
    package require tdom
    package require sqlite3
    source "[MiSynPatDir]/src/PageMaker.tcl"
    LesDefauts
    set LesHumi {}
    foreach System [MSP Syn ListOf System] {
	set humi [PageMaker $System "LoadTabSF"]
Espionne $humi
	set SeqDe($humi) $::Sequences($humi)
	lappend LesHumi $humi
	array set TabSFOnDisk [array get ::TabSF]
    }
    set TabSFOnDisk("EstCharge") 1
    foreach humi $LesHumi {
	set TabSFOnDisk($humi,seq) $SeqDe($humi)
	set TabSFOnDisk($humi,exists) 1
	lappend TabSFOnDisk(ListOf,humi) $humi
    }
    Sauve [array get TabSFOnDisk] dans $FichierTabSFOnDisk
    return [TabSFOnDisk $Qui $Quoi]
}

proc LesVertebrata {{GetWhat ""}} {
    set LesOXOS {}
    foreach Ligne [lsort [LesLignesDuFichier "[MiSynPatDir]/data/alignments/Vertebrata/VertebrataListOfOS.txt"]] {
	set OS $Ligne
	set OX [Tax $OS]
	lassign [split $OS " "] Ge Es
	set Code [string range $Ge 0 3].[string range $Es 0 3]
	lappend LesOX $OX
	lappend LesOS $OS
	lappend LesOXOS "$OX $OS"
	lappend LesOXGEOS "$OX / $Code / $OS"
    }
    if {$GetWhat=="OX"} { return $LesOX }
    if {$GetWhat=="OS"} { return $LesOS }
    if {$GetWhat=="OXOS"} { return $LesOXOS }
    if {$GetWhat=="OXGEOS"} { return $LesOXGEOS }
    return $LesOXOS
}

proc SynthetasesOfVertebrates {} {
    #set LesA [split [QuestionDeScience MSP "ret MSP Syn ListOf A"] " "]
    set LesA [MSP Syn ListOf A]
    foreach A $LesA {
	#set ARS [QuestionDeScience MSP "ret MSP Syn $A System"]
	set ARS [MSP Syn $A System]
	set Nom [RepereBox "Alias: $ARS" AllPlease]
	if {[llength $Nom]>1} { FaireLire "$A $ARS tope $Nom"; continue }
	Espionne "$A $ARS $Nom"
	set BlastFile [GscopeFile $Nom "blastpVertebrata2017"]
	Espionne $BlastFile
	if {[FileAbsent $BlastFile]} { FaireLire "$A $ARS $Nom pas de blast" ;continue }
	
	set LesBAI($A) {}
	set OnAttendChevron 1
	set OnAttendQuery 0
	foreach Ligne [LesLignesDuFichier $BlastFile] {
	    if { $OnAttendChevron } {
		if { ! [regexp "^>" $Ligne]} { continue }
		set LesInfo {}
		lappend LesInfo $Ligne
		scan $Ligne "%s" BAI
		regsub ">" $BAI "" BAI
		lappend LesBAI($A) $BAI
		set OnAttendQuery 1
		set OnAttendChevron 0
		continue
	    }
	    if {$OnAttendQuery} {
		if {[regexp "^Query:" $Ligne]} {
		    set Info [join $LesInfo " "]
		    regsub -all { +} [string trim $Info] " " Info
		    set InfosDe($BAI) $Info 
		    set OnAttendChevron 1
		    set OnAttendQuery 0
		}
		lappend LesInfo $Ligne
		continue
	    }
	}
	foreach BAI $LesBAI($A) {
	    set Info $InfosDe($BAI)
	    set Positives ""
	    regexp {Positives = ([0-9]+/[0-9]+)} $Info Match Positives
	    set OI [StringApres "OI=" dans $Info]
	    if {[info exists DejaVu($A,$OI)]} { continue }
	    set DejaVu($A,$OI) 1
	    lassign [split $Info "="] Debut
	    regsub {^[^ ]+ } $Debut "" DE
	    regsub " OS" $DE "" DE
	    regexp { ([0-9]+/[0-9]+)} $Info Match Positives
	    Espionne "$A $OI $Positives $DE"
	}
    }	
}


proc AliFromOiPoch {{ListOfA ""}} {
    set RepSrcXml "/home/poch"
    set RepDesXml "/home/ripp/msp/data/alignments/Vertebrata/macsimXmlPoch20170602"
    set LesElus {}

    if {$ListOfA==""} { set ListOfA [MSP Syn ListOf A] }

    foreach A $ListOfA {
	set Nom [MSP Syn $A Nom]
	set Name "${A}mito_Homo.sapi"
	set Accession [MSPFroMac $Nom TDesAccess $Name]
	set NomHs [QuestionDeScience "EHomsa" "ret NIAG $Accession N"]
	if {$NomHs==""} {
	    set NomHs [QuestionDeScience "EHomsa" "ret NIAG SY${A}M_HUMAN N"]
	}
	if {$NomHs==""} {
	    set NomHs [QuestionDeScience "EHomsa" "ret NIAG SY${A}_HUMAN N"]
	}
	Espionne "$A $Accession $NomHs"
#	Espionne [QuestionDeScience "EHomsa" "ret ExtraitInfo $NomHs"]
	if {$NomHs==""} { continue }
	set Queue "${Name}_Poch.xml"
	set FichierSrc "$RepSrcXml/$Queue"
	Espionne $FichierSrc
	set LeXml [LesLignesDuFichier $FichierSrc]
	set LeNew {}
	set OX ""
	if {[info exists DejaVu]} { unset DejaVu }
	set LaSequenceCourante {}
	set DansSequence 0
	set OnGarde 1
	if {$A=="G"} { set Name "P41250" }
	foreach Ligne $LeXml {
	    if {[regexp "</sequence" $Ligne]} {
		lappend LaSequenceCourante $Ligne
		if {$OnGarde} {
		    LConcat LeNew $LaSequenceCourante
		}
		set LaSequenceCourante {}
		set DansSequence 0
		continue
	    }
	    if  {[regexp "<sequence" $Ligne]} {
		lappend LaSequenceCourante $Ligne
		set DansSequence 1
		set OnGarde 1
		continue
	    }
	    if { ! $DansSequence } {
		lappend LeNew $Ligne
		continue
	    }
	    set SeqName ""
	    if {[regexp {<seq\-name>([^<]+)</seq\-name>} $Ligne Match SeqName]} {
		if {$A!="G" && $SeqName==$Name} { set OnGarde 0 }
		if {$A=="G" && $SeqName=="Gmito_Homo.sapi"} { set OnGarde 0 }
		if {$SeqName!="" && ($SeqName!=$Name || $SeqName=="P41250") } {
		    set R [QuestionDeScience GeneQuid "ret UniprotData $SeqName ID,GN,OX"]
		    scan $R "%s" Id
		    set Gn [StringApres "Name=" dans $R]
		    set OX [IntegerApres "NCBI_TaxID=" dans $R]
		    lappend LesOX($A) $OX
		    lappend DejaVu($A,$OX) "$SeqName : \n$R"
		    set OS [OiCodeForDomain Eukaryota $OX OS]
		    lassign [split $OS " "] Ge Es
		    set Es [string trim $Es "."]
		    set Code [string totitle [string range $Ge 0 3]].[string tolower [string range $Es 0 3]]
		    Espionne ""
		    Espionne $OnGarde
		    Espionne "$Id $Gn $Ligne"
		    if {[regexp -nocase "^${A}ARS2" $Gn] || ([regexp -nocase {^[GK]ARS} $Gn] && $SeqName!="P41250") || [regexp -nocase "^SY${A}M" $Id]} {
			if {[regexp {^([^_]+)_(.+)$} $Id Match Ac Os]} {
			    set XmitoGenrespe ${A}mito_$Code
			    if {[info exists DejaVu($XmitoGenrespe)]} { append XmitoGenrespe 2 }
			    set DejaVu($XmitoGenrespe) 1
			    set Ligne "<seq-name>$XmitoGenrespe</seq-name>"
			}
		    } elseif {[regexp -nocase "^SY${A}C" $Id]} {
			set XcytoGenrespe ${A}cyto_$Code
			if {[info exists DejaVu($XcytoGenrespe)]} { append XcytoGenrespe 2 }
			set DejaVu($XcytoGenrespe) 1
			set Ligne "<seq-name>$XcytoGenrespe</seq-name>"
		    } else {
		    }
		    #rR Traitement spécial pour GARS car on ne sait pas s'ils sont cyto ou mito
		    Espionne $Ligne
		    if {$A=="G" && ! [regexp "Homo.sapi" $Ligne] && [regexp {<seq\-name>G(cyto|mito)_} $Ligne]} {
			regsub {<seq\-name>G(cyto|mito)_} $Ligne "<seq-name>G_" Ligne
		    }
		    Espionne "regexp {<seq\-name>P41250</seq\-name>} $Ligne"
		    if {$A=="G" && [regexp {<seq\-name>P41250</seq\-name>} $Ligne]} {
			regsub {<seq\-name>P41250</seq\-name>} $Ligne "<seq-name>Gcyto_Homo.sapi</seq-name>" Ligne
		    } 
		    if {0 && $A=="G" && [regexp {<seq\-name>A0A091E8Q8</seq\-name>} $Ligne]} {
			regsub {<seq\-name>A0A091E8Q8</seq\-name>} $Ligne "<seq-name>Gmito_Homo.sapi</seq-name>" Ligne
		    } 

		}
	    }
	    if {[regexp {<seq\-data>([^<]+)</seq\-data>} $Ligne Match SeqGap]} {
		set SeqGap [string toupper $SeqGap]
		regsub -all {[^A-Z]} $SeqGap "" Seq
		set SeqDe($A,$OX) $Seq
		lappend LesAOXDeSeq($Seq) "$A,$OX"
		lappend LesSeq $Seq
	    }
	    lappend LaSequenceCourante $Ligne
	}
	
	foreach Seq $LesSeq {
	    if {[llength LesAOX($Seq)]>1} {
		Espionne "SequencesDoublons"
		Espionne [join LesAOXDeSeq($Seq) " "]
	    }
	}
	
	lappend LesErreurs ""
	set MessageEntete "$A **************************** "
	Espionne $MessageEntete
	set LesOX($A) [lsort -unique $LesOX($A)]
	foreach OX $LesOX($A) {
	    if {[llength $DejaVu($A,$OX)]>1} {
		lappend LesErreurs ""
		lappend LesErreurs $MessageEntete
		set Message [join $DejaVu($A,$OX) "\n\n"]
		lappend LesErreurs $Message
		Espionne $Message
	    }
	}
	lappend LesElus [SauveLesLignes $LeNew dans $RepDesXml/$Queue]
    }
    SauveLesLignes $LesErreurs dans $RepDesXml/Doubles.txt
    return $LesElus
}

proc AliFromOi {} {
    set RepSrcXml "/genomics/link/EHomsa/macsimXmlVertebrata2017"
    set RepSrcRsf "/genomics/link/EHomsa/macsimRsfVertebrata2017"
    set RepDesXml "/home/ripp/msp/data/alignments/Vertebrata/macsimXml"
    set RepDesRsf "/home/ripp/msp/data/alignments/Vertebrata/macsimRsf"
    set LesElus {}
    foreach A [MSP Syn ListOf A] {
	set Nom [MSP Syn $A Nom]
	set Name "${A}mito_Homo.sapi"
	set Accession [MSPFroMac $Nom TDesAccess $Name]
	set NomHs [QuestionDeScience "EHomsa" "ret NIAG $Accession N"]
	if {$NomHs==""} {
	    set NomHs [QuestionDeScience "EHomsa" "ret NIAG SY${A}M_HUMAN N"]
	}
	if {$NomHs==""} {
	    set NomHs [QuestionDeScience "EHomsa" "ret NIAG SY${A}_HUMAN N"]
	}
	Espionne "$A $Accession $NomHs"
	Espionne [QuestionDeScience "EHomsa" "ret ExtraitInfo $NomHs"]
	if {$NomHs==""} { continue }
	set Xml [ContenuDuFichier $RepSrcXml/$NomHs]
	regsub -all $NomHs $Xml $Name Xml
	Sauve $Xml dans $RepDesXml/$Name.xml
	file copy -force $RepSrcXml/$NomHs $RepDesXml/$NomHs.xml
	foreach Rsf [glob -nocomplain $RepSrcRsf/$NomHs*] {
	    file copy -force $Rsf $RepDesRsf/
	    set Queue [file tail $Rsf]
	    regsub $NomHs $Queue $Name Queue
	    file copy -force $Rsf $RepDesRsf/$Queue
	}
	lappend LesElus "$A $Nom $Name"
    }
    return $LesElus
}

proc FromTabSFOnDisk {{Qui ""} {Quoi ""}} {
    #rR Pour tester TabSFOnDisk à partir de gscope
    global TabSFOnDisk
    if {[info exists TabSFOnDisk($Qui,$Quoi)]}  { return $TabSFOnDisk($Qui,$Quoi) }
    if {[info exists TabSFOnDisk("EstCharge")]} { return "" }
    set TabSFOnDisk("EstCharge") 1

    set FichierTabSFOnDisk "[MiSynPatDir]/TabSFOnDisk.txt"
    if { ! [FileExists $FichierTabSFOnDisk]} { return "" }
    array set TabSFOnDisk [ContenuDuFichier $FichierTabSFOnDisk]
    set TabSFOnDisk("EstCharge") 1
    return [FromTabSFOnDisk $Qui $Quoi]
}


proc RajouteMut3LAuTitre Titre {
    set I 0
    while {[regexp -start $I -indices { [A-Z][0-9]+[A-Z]( |$)} $Titre Indices]} {
	lassign $Indices D F
	set Mut [string range $Titre $D $F]
	set I $F
	set Mut3L [Mut3L $Mut]
	set Titre [string replace $Titre $D $F " $Mut $Mut3L "]
    }
    return $Titre
}

proc Mut3L A123B {
    set A123B [string trim $A123B]
    if { ! [regexp {^([A-Z])([0-9]+)([A-Z])$} $A123B Match W Pos M]} { return "" }
    set Wil [string totitle [UT $W]]
    set Mut [string totitle [UT $M]]
    if {$M=="X"} { set Mut "*" }
    set Mut3L "p.$Wil$Pos$Mut"
    return $Mut3L
}

proc ListeOrgMsp {} {
    #rR j'ai pas vraiment fini .. .Marie l'a fait à la main voir SuppTable1
    
    array set Domaines [list cyanobacterie cyanobacteria bacterie bacteria archae archae eukaryotes eukaryota  alpha-proteobacterie  alpha-proteobacteria]
    foreach Ligne [LesLignesDuFichier "[MiSynPatDir]/article/ListeMarie.txt"] {
	set LesMots [LesMotsDuTexte $Ligne]
	set Ligne [join $LesMots " "]
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }
	regsub {\(.+$} $Ligne "" Ligne 
	regsub {^/[^ ]+ } $Ligne "" Ligne
	set Ligne [string trim $Ligne]
	Espionne "=$Ligne="
	if {[info exists Domaines($Ligne)]} {
	    set Domaine $Domaines($Ligne)
	    lappend LeNew ""
	    lappend LeNew $Domaine
	    continue
	}
	set OS $Ligne
	Espionne "=$OS="
	
	if {$OS=="Brachydanio rerio"} { set OS "Danio rerio" }
	regsub "Methanococcus jannaschii" $OS "Methanocaldococcus jannaschii" OS
	regsub "Methanobacterium thermoautotrophicum" $OS "Methanothermobacter thermautotrophicus" OS
	regsub "Borrelia burgdorferi" $OS "Borreliella burgdorferi" OS
	regsub "Chlamydophila pneumoniae" $OS "Chlamydia pneumoniae" OS
	regsub "Chlorobium tepidum" $OS "Chlorobaculum tepidum" OS
	set OXde(Dehalococcoides_ethenogenes) [Tax "Dehalococcoides mccartyi"]
	regsub { sp$} $OS " sp." OS
	regsub -all " " $OS "_" OSU
	if {[info exists OXde($OSU)]} {
	    set OX $OXde($OSU)
	} else {
	    set OX [Tax $OS]
	}
	set E ""
	scan $OS "%s %s" G E
	set Code "[string range $G 0 3].[string range $E 0 3]"
	if {$Code=="Nost."} { set Code "Anab.sp" }
	if {$Code=="Syne."} { set Code "Syne.sp" }
	lappend LeNew "$OX\t$Code\t$OS"
    }
    return $LeNew
    exit
    foreach Ligne [LesLignesDuFichier "[MiSynPatDir]/article/ListeOG.txt"] {
	set LesMots [LesMotsDuTexte $Ligne]
	set Code     [lindex $LesMots 0]
	set Domaine  [lindex $LesMots end]
	set OX       [lindex $LesMots end-1]
	set OS [join [lrange $LesMots 1 end-2] " "]
	set OS [string trim $OS " ."]
	regsub {a\-proteobact\.} $Domaine "alpha-proteobacteria" Domaine
	regsub {bact\.}          $Domaine "bacteria" Domaine
	regsub {eukar\.}         $Domaine "eukaryota" Domaine
	#Espionne "$Code $OX $Domaine $OS"
	if {[Tax $OX]!=$OS} { Espionne "$OX [Tax $OX]!=$OS" }
	if {[Tax $OS]!=$OX} { Espionne "$OS [Tax $OS]!=$OX" }
    }
    exit
}

proc VerifieLesMutations {} {
    set LesMauvais {}
    foreach Nom [ListeDesPABs] {
	set Seq1 x[string toupper [QueLaSequenceDuFichierTFA [GscopeFile $Nom "prottfa"]]]
	set Seq1 x[SeqMac $Nom]
	set A [NomDeMSP $Nom A]
	set LesMutations [lsort -unique [concat [MSP Mut $A ListOfV1] [MSP Mut $A ListOfV2]]]
	foreach A123B $LesMutations {
	    if { ! [regexp {([A-Z])([0-9]+)([A-Z])} $A123B Match W P M]} { FaireLire "$Nom $A $A123B merde !"; continue }
	    if {$W=="X"} { continue }
	    if {[string index $Seq1 $P]!=$W} {
		set Message "$Nom $A en $A123B [string index $Seq1 $P]!=$W  [string range $Seq1 $P-5 $P+5]"
		Espionne $Message
		lappend LesMauvais $Message
	    }
	}
    }
    return $LesMauvais
}

proc MitoHs Qui {
    #rR Rend le Amito_Homo.sapi en fonction de toute info qui y fait référence : A Ala MSP01 ...
    global MitoHs
    set A [NomDeMSP $Qui A]
    if {[regexp {^[A-Z]$} $A]} { return "${A}mito_Homo.sapi" }
    return ""
}

proc SeqMac {Nom {D ""} {F ""}} {
    #rR ici onprend la sequence par MspFroMac
    #rR Elle est aussi disponible pas MSP Syn Y SeqWithGap  (ou SeqWithoutGap)
    set SeqGap [MSPFroMac $Nom Sequences [MitoHs $Nom]]
    set SeqGap [string toupper $SeqGap]
    regsub -all -nocase {[^a-z]} $SeqGap "" SeqMac
    if {$F==""} { set F $D }
    if {$D!=""} { return [string range x$SeqMac $D $F] }
    return $SeqMac
} 

proc VerifieCoherence {} {
    foreach Nom [ListeDesPABs] {
	set A [NomDeMSP $Nom A]
	set MitoHs [MitoHs $Nom]
	set SeqMac [SeqMac $Nom]
	set SeqTfa [string toupper [QueLaSequenceDuFichierTFA [GscopeFile $Nom "prottfa"]]]
	if {[string equal $SeqMac $SeqTfa]} { continue }
	Espionne "$Nom $A Mac $SeqMac"
	Espionne 
	Espionne "$Nom $A Tfa $SeqTfa"
	FaireLire $Nom	
    }
}

proc TLN {} {
    set Xml [ContenuDuFichier "/home/ripp/msp/exemp.txt"]
    if {[regexp {LastName.Kars}      $Xml Match]} { Espionne "$Match"; set Saute($Pmid) 1 }
    exit
}

proc SP {{Menage ""} {Test ""}} {

    #rR Attention InfoPubmed fait une mémorisation en fonction du MD5 de LesPmids

    package require tdom

    set Test [string equal -nocase $Test "Test"]
    if {$Test} {
	set LesT [SurveillancePubmed GetResult]
	set LesA [SurveillancePubmed GetResult AllFields]
	set LesTuA [ListsUnion        $LesT $LesA]
	set LesTiA [ListsIntersection $LesT $LesA]
	set LesTnA [ListsComplement   $LesT $LesA]
	set LesAnT [ListsComplement   $LesA $LesT]

	#    set LesPmids [concat [lrange $LesAnT 0 5] [lrange $LesTiA 0 5]]
	set LesPmids [lrange $LesA 0 end]
	set LesDejaVu [SqlExecForDatabase MiSynpat "select pmid from biblio" "GetList"]
	foreach L [list LesTuA LesTiA LesTnA LesAnT LesDejaVu] {
	    Espionne "$L [llength [set $L]]"
	}
    } else {
	set LesPmids [SqlExecForDatabase MiSynPat "select pmid from biblio where accepted=-1 OR accepted=2" "GetList"]
    }

    set Menage [string equal -nocase $Menage "Menage"]

    set LeH {}
    lappend LeH "<!DOCTYPE html>"
    lappend LeH "<html>"
    lappend LeH "  <head>"
    lappend LeH "    <meta charset='UTF-8'>"
    lappend LeH "  </head>"
    lappend LeH "  <body>"
    lappend LeH "    <div style='width:60%; margin-left:20%'>"

    lappend LeH "<h5>"
    if {$Test} {
	lappend LeH "Bonjour Marie.<br/>"
	lappend LeH "A bientôt :)<br/>"
	lappend LeH "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;           Raymond"
	lappend LeH "</h5>"
    } else {
	lappend LeH "Bonjour.<br/>"
	lappend LeH "Cette page affiche en clair tous les pmids à traiter."
	lappend LeH "A bientôt :)<br/>"
	lappend LeH "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;           Raymond"
	lappend LeH "</h5>"
    }

    set NbNew 0

    if {0 && $Test} {
	set TexteXml [eSummaryREST pubmed $LesPmids "" "GetXml"]
	
	while {[set Xml [ValeurDeLaBalise "DocSum" TexteXml]]!=""} {
	    set Pmid ""
	    regexp {<Id>([0-9]+)</Id>} $Xml Match Pmid
	    Espionne $Pmid
	    if {[regexp 27625683 $Xml]} { Espionne $Xml }
	    if {[regexp {Kars[ \,]*Turkey} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
	}
    }
    if {0 && $Test} {
	set LesKarsTurkey [split [ContenuDuFichier "/home/ripp/msp/KarsTurkey.txt"] "\n "]
	foreach Pmid $LesKarsTurkey {
	    set Saute($Pmid) 1
	}
    }

    foreach Pmid $LesPmids {
	Espionne $Pmid
	if {[info exists Saute($Pmid)] } { continue }
	if {$Menage} {
	    set Xml [ContenuDuFichier "https://www.ncbi.nlm.nih.gov/pubmed/$Pmid/&format=text?report=xml&format=text"]
	    #Espionne $Xml
	    if {[regexp {Kars[ \,]*TR}       $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
	    if {[regexp {Kars[ \,]*Turkey}   $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
	    if {[regexp {Kafkas[^\n]+Kars}   $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
	    if {[regexp {Hospital[^\n]+Kars} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
	    if {[regexp {LastName[^\n]+Kars} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
	    if {[regexp {LastName[^\n]+Gars} $Xml Match]} { Espionne "$Pmid $Match"; set Saute($Pmid) 1 ; continue }
	}
	if {[info exists Saute($Pmid)] } { continue }
	set DejaVu ""
	set ColorDejaVu "red"
	set Origin ""
	set ColorOrigin "green"
	if {$Test} {
	    if {[lsearch $LesDejaVu $Pmid]<0} {
		set DejaVu "Is not yet in Database"
		set ColorDejaVu "red"
	    } else {
		set DejaVu "Is in Database"
		set ColorDejaVu "green"
		continue
	    }
	    if {[lsearch $LesT $Pmid]<0} {
		set Origin "Query in Title/Abstract (should be in the database)"
		set ColorOrigin "green"
	    } else {
		set Origin "Query in All Fields"
		set ColorOrigin "red"
	    }
	}
	set Title    [InfoPubmed $LesPmids $Pmid Title]
	set Abstract [InfoPubmed $LesPmids $Pmid Abstract]
	
	regsub -all "\n" $Abstract "<br/>\n" Abstract

	lappend LeH "<br/>"
	lappend LeH "<br/>"
	lappend LeH "<a target='_blank' href='https://www.ncbi.nlm.nih.gov/pubmed/$Pmid'>$Pmid</a> <span style='color:$ColorOrigin;'>$Origin</span> <span style='color:$ColorDejaVu;'>$DejaVu</span>"
	lappend LeH "<br/>"
	lappend LeH "<h4><i>$Title</i></h4>"
	lappend LeH $Abstract
	lappend LeH ""
	incr NbNew
    }
    Espionne $NbNew
    lappend LeH "    </div>"
    lappend LeH "  </body>"
    lappend LeH "<html>"
    set Html [join $LeH "\n"]

    set Query [SurveillancePubmed GetQuery]
    foreach {Bidon Hit } [split $Query "\""] {
	if {[regexp {^[0-9]+$} $Hit]} { continue }
	if { ! [regexp -nocase {^[a-z0-9]+$} $Hit]} { continue }
	lappend LesHits $Hit
    }
    Espionne $LesHits
    foreach Hit $LesHits {
	regsub -nocase -all $Hit $Html "<span style='background-color:lightgreen';>&</span>" Html
    }
    regsub -nocase -all mito       $Html "<span style='background-color:pink';>&</span>" Html
    regsub -nocase -all trna       $Html "<span style='background-color:pink';>&</span>" Html
    regsub -nocase -all synthetase $Html "<span style='background-color:pink';>&</span>" Html
    
    if {$Menage} { return "" }
    return $Html
}

proc InfoPubmed {Pmids {Qui ""} {Quoi ""}} {
    global InfoPubmed

    if {[regexp {[^0-9]} $Pmids]} {
	regsub -all {[^0-9]} $Pmids " " Pmids
	set Pmids [split [string trim $Pmids] " "]
    }

    if {[info exists InfoPubmed($Pmids,$Qui,$Quoi)]} { return $InfoPubmed($Pmids,$Qui,$Quoi) }
    if {[info exists InfoPubmed($Pmids,"EstCharge")]} { return "" }
    set InfoPubmed($Pmids,"EstCharge") 1

    package require md5
    set MD5 [::md5::md5 -hex $Pmids]
    set Fic "/home/ripp/msp/sp_$MD5"
    if {[file exists $Fic]} {
	array set InfoPubmed [ContenuDuFichier $Fic]
	return [InfoPubmed $Pmids $Qui $Quoi]
    }

    set InfoPubmed($Pmids,All,Title)    {}
    set InfoPubmed($Pmids,All,Abstract) {}
    set InfoPubmed($Pmids,All,All)      {}
    
    set Linfo [eFetchREST pubmed $Pmids]
    array set Tinfo $Linfo
    foreach Pmid $Pmids {
	if {[info exists Tinfo]} {
	    #unset Tinfo
	}

	#set Linfo [eFetchREST pubmed $Pmid]
	#array set Tinfo $Linfo
#	#parray Tinfo
	set InfoPubmed($Pmids,$Pmid,All) {}
	foreach {K V} [array get Tinfo] {
	    lappend InfoPubmed($Pmids,$Pmid,All) "$K=$V"
	}
	set InfoPubmed($Pmids,$Pmid,All) [join $InfoPubmed($Pmids,$Pmid,All) "\n"]
	if {! [info exists Tinfo($Pmid,Title)] && ! [info exists Tinfo($Pmid,Abstract)] && ! [info exists Tinfo($Pmid,PubYear)]} {
	    lappend InfoPubmed($Pmids,ListOf,Ko) $Pmid
	    continue
	}
	lappend InfoPubmed($Pmids,ListOf,Ok) $Pmid
	set InfoPubmed($Pmids,$Pmid,Title)    $Tinfo($Pmid,Title)
	set InfoPubmed($Pmids,$Pmid,Abstract) $Tinfo($Pmid,Abstract)
	set InfoPubmed($Pmids,$Pmid,PubYear)  $Tinfo($Pmid,PubYear)
	set InfoPubmed($Pmids,$Pmid,PubMonth) $Tinfo($Pmid,PubMonth)
	set InfoPubmed($Pmids,$Pmid,LAuthors) $Tinfo($Pmid,LAuthors)
	lappend InfoPubmed($Pmids,All,Title)    "$Pmid $InfoPubmed($Pmids,$Pmid,Title)"
	lappend InfoPubmed($Pmids,All,Abstract) "$Pmid $InfoPubmed($Pmids,$Pmid,Abstract)"
	lappend InfoPubmed($Pmids,All,All)      "$Pmid $InfoPubmed($Pmids,$Pmid,All)"
    }
    set InfoPubmed($Pmids,All,Title)    [join $InfoPubmed($Pmids,All,Title)    "\n"]
    set InfoPubmed($Pmids,All,Abstract) [join $InfoPubmed($Pmids,All,Abstract) "\n"]
    set InfoPubmed($Pmids,All,All)      [join $InfoPubmed($Pmids,All,All)      "\n"]
    #rR Sauve [array get InfoPubmed] dans $Fic
    return [InfoPubmed $Pmids $Qui $Quoi]
}

proc MiseAJourDatesBiblio {{pmid ""}} {
    set Where ""
    if {$pmid!=""} { set Where "where pmid=$pmid" }
    set LesRecords [SqlExecForDatabase "MiSynPat" "select pmid,datem,datey,pk_biblio from biblio $Where" "GetListOfList"]
    set NbTot   0
    set NbOk    0
    set NbEmpty 0
    set NbADiff 0
    set LesUpdate {}
    set Ltmp [lmap x $LesRecords {lindex $x 0}]
    
    set Lrest [eSummaryREST pubmed $Ltmp]
    array set T $Lrest
    foreach Record $LesRecords {
	lassign $Record P M A Pk
	#set Lrest [eSummaryREST pubmed $P]
	#array set T $Lrest
	if { ! [info exists T($P,PubDate)]} {
	    continue
	}
	incr NbTot
	set PubDate $T($P,PubDate) 
	Espionne $PubDate
	lassign [split $PubDate " -"] PA PM
	Espionne "$A=$PA $PM=$M="
	if {$A!="" && $A!=$PA} {
	    incr NbADiff ; continue
	}
	if {$M==$PM && $A==$PA} {
	    incr NbOk ; continue
	}
	if {$M=="" || $A==""} {
	    if {[Month1to12 $PM]!=0 } {
		set Update "update biblio set datem='$PM', datey='$PA' where pk_biblio=$Pk"
		lappend LesUpdate $Update
	    } 
	    incr NbEmpty
	} else {
	    incr NbDiff
	}
	Espionne "$P $A = $PubDate = $M"
    }
    Espionne "[llength $LesRecords] $NbADiff $NbTot $NbOk $NbEmpty"
    set LesUpdateAFaire [split [AfficheListe $LesUpdate "AvecRetour"] "\n"]
    foreach Update $LesUpdateAFaire {
	Espionne $Update
	#SqlExecForDatabase "MiSynpat" $Update
    }
    return $LesUpdate
}

proc TriParMoisAnnee {R1 R2} {
    lassign $R1 M1 A1
    if {$M1==""} { set M1 Juin }
    lassign $R2 M2 A2
    if {$M2==""} { set M2 Juin }
    return [CompareDate "$M1 $A1" "$M2 $A2"]    
}

proc MspBiblioGrowth {{GetWhat ""}} {
    if {$GetWhat==""} { set GetWhat "GetCouplesDates" }
    set LesRecords [SqlExecForDatabase "MiSynPat" "select datem,datey,pk_biblio,accepted,pmid from biblio where accepted=1" "GetListOfList"]
    set LesRecords [lsort -command TriParMoisAnnee $LesRecords]

    set LesMA {}
    set FirstA 2007
    set FirstM 0
    set MaxSince 0
    foreach Record $LesRecords {
	lassign $Record M A P V Pmid
	Espionne "$Record"
	if {$V<1} { continue }
	if {$A==""} { set A 2012 }
	if {$M==""} { set M "Jun" }
	if {[regexp {^[0-9]+$} $M]} {
	    #rR si le mois est donné en chifre ... on enleve les leading 0"
	    set N $M
	    regsub {^0+} $N "" N
	} else {
	    set N [Month1to12 $M]
	}
#	if {$FirstA==""} { set FirstA $A ; set FirstM $N }
	set Since [expr ($A-$FirstA)*12 + $N-$FirstM]
	set MaxSince [Maxi $MaxSince $Since]
	incr Occu($Since)
	set DateDe($Since) "$A-[format %2.2d $N]"
#	set DateDe($Since) "$M-$A"
    }
    set LesSince {}
    foreach Since [NombresEntre 0 $MaxSince] {
	if { ! [info exists Occu($Since)]} {
	    set Occu($Since) 0
	}
	lappend LesSince $Since
    }
    set Cumul 0
    set LesCouplesDates {}
    foreach Since $LesSince {
	lappend LesOccu $Occu($Since)
	incr Cumul $Occu($Since)
	lappend LesCouples "\[$Since, $Cumul\]" 
	if {[info exists DateDe($Since)]} { lappend LesCouplesDates "\['$DateDe($Since)', $Cumul\]"  }
	lappend LesCumul $Cumul
    }
    EspionneL $LesCouplesDates
    set CouplesDates [join $LesCouplesDates ","]

    if {$GetWhat=="GetCouplesDates"} { return $CouplesDates }

    set Couples [join $LesCouples ","]
    Espionne "\[\[$CouplesDates\]\]"
    Espionne "\[\[$Couples\]\]"
    Espionne $LesSince
    Espionne $LesOccu
    return [Graphe $LesSince $LesCumul]
}

proc MspRuns {} {

    set LeStatus {}


    set Url "http://misynpat.org/misynpat/"
    set Top [FromProtUrl $Url 2316apriseparcoeur 1623100Raphael]

    if {$Top!=[ContenuDuFichier "/home/ripp/msp/HtmlModeles/Top.html"]} {
#	Espionne "Merde Top"
	lappend LeStatus 0
    } else {
#	Espionne "Ok Top"
	lappend LeStatus 1
    }


    set Url "http://misynpat.org/misynpat/ConservationDesMutationsEtStat.rvt?name=DARS2"
    set Mut [FromProtUrl $Url 2316apriseparcoeur 1623100Raphael]

    if {$Mut!=[ContenuDuFichier "/home/ripp/msp/HtmlModeles/Mut.html"]} {
#	Espionne "Merde Mut"
	lappend LeStatus 0
    } else {
#	Espionne "Ok Mut"
	lappend LeStatus 1
    }

    set Status [join $LeStatus ""]
    if {[regexp "0" $Status]} {
	send_simple_message "raymond.ripp@unistra.fr" localhost "MspRuns with status $Status" "hihi" "misynpat@lbgi.fr"
    }
    return "MspRuns with status $Status"
}


proc CreateLinkInMacsimXmlMisynpat {} {
    set XmlDir "[MiSynPatDir]/data/alignments"
    set RepMacimXml "[RepertoireDuGenome]/macsimXml_Misynpat"
    file mkdir $RepMacimXml
    NousAllonsAuBoulot $RepMacimXml
    foreach Nom [ListeDesPABs] {
	set A [ExtraitInfo $Nom A] 
	set XmlFic "$XmlDir/${A}_WithModules.xml"
	Espionne $XmlFic
	exec ln -sf $XmlFic $Nom
    }
    OnRevientDuBoulot
    return
}

proc OuSontLesMutations {{GetWhat ""} {AllOrA ""} {Conservation ""} {Order ""} {Action ""}} {
    #rR-Permet de voir en gros comment sont réparties les mutations
    #rR-OuSontLesMutations Help                     (Help ... W means Wildtype (source), M means Mutation (destination)) 
    #rR OuSontLesMutations WM                       (See howmany times each AA appears as source and destination of a mutation) 
    #rR OuSontLesMutations Types                    (See howmany times each Type of AA appears as source and destination of a mutation)
    #rR OuSontLesMutations 
    #rR OuSontLesMutations Modules  All             (Number of mutations per structural module  for all systems)
    #rR OuSontLesMutations FromWtoM All             (Number of occurrences of each substitution for all systems)
    #rR OuSontLesMutations FromWtoM All All-Cons    (Number of occurrences of each substitution for all systems on conserved positions) 
    #rR OuSontLesMutations FromWtoM All IdenCons    (Number of occurrences of each substitution for all systems on 100/100 conserved positions) 
    #rR OuSontLesMutations FromWtoM All ConsCons    (Number of occurrences of each substitution for all systems on  80/100 conserved positions) 
    #rR OuSontLesMutations FromWtoM All SimiCons    (Number of occurrences of each substitution for all systems on physicochemically conserved positions) 
    #rR OuSontLesMutations FromWtoM All NoCons      (Number of occurrences of each substitution for all systems on non conserved positions) 
    #rR OuSontLesMutations 
    #rR OuSontLesMutations Modules  D           (Number of mutations per structural module)                                        for Any AA
    #rR OuSontLesMutations FromWtoM D           (Number of occurrences of each substitution)                                       for Any AA
    #rR OuSontLesMutations FromWtoM D All-Cons  (Number of occurrences of each substitution on conserved positions)                for Any AA
    #rR OuSontLesMutations FromWtoM D IdenCons  (Number of occurrences of each substitution on 100/100 conserved positions)        for Any AA
    #rR OuSontLesMutations FromWtoM D ConsCons  (Number of occurrences of each substitution on  80/100 conserved positions)        for Any AA
    #rR OuSontLesMutations FromWtoM D SimiCons  (Number of occurrences of each substitution physicochemically conserved positions) for Any AA
    #rR OuSontLesMutations FromWtoM D NoCons    (Number of occurrences of each substitution on non conserved positions)            for Any AA

    if {$Action=="-"}       { set Action "" }
    if {$Order=="-"}        { set Order  "" }
    if {$Conservation=="-"} { set Conservation "" }
    if {$AllOrA=="-"}       { set AllOrA "" }
    if {$GetWhat=="-"}      { set GetWhat "" }
    
    if {$Action==""} { set Action "Show" }

    if {[regexp -nocase "ars" $AllOrA]} {
	set AllOrA [MSP Syn [string toupper $AllOrA] A]
    }

    if {$GetWhat==""} { set GetWhat "Help" }
    if {$GetWhat=="Help"} {
	set LeHelp {}
	set LeHelpText {}
	foreach Ligne [split [info body OuSontLesMutations] "\n"] {
	    if { ! [regexp "#rR +OuSont" $Ligne]} { continue }
	    regsub "#rR " $Ligne "" Text
	    lappend LeHelpText $Text
	    regsub "#rR " $Ligne {http://lbgi.fr/wscoperr?MSP\&} Ligne
	    regsub -all { +} $Ligne " " Ligne
	    set Ligne [string trim $Ligne]
	    set Ref $Ligne
	    regsub { +\(.*$} $Ref ""   Ref
	    regsub -all " "  $Ref {\&} Ref
	    lappend LeHelp $Ligne
	    regsub {^[^&]+&} $Ligne "" Text
	    lappend LesRefText $Ref $Text
	}
	if {[PourWscope]} {
	    if {$Action=="GetAsText"} { return [join $LeHelpText "\n"] }
	    return [Html_ListOfRefs $LesRefText "<center><h3>Où sont les mutations ?</h3></center>"]
	}
	if {$Action=="GetAsText"} { return [join $LeHelp "\n"] }
	return [AfficheListe $LeHelp]
    }

    #rR On met ConsLocal car on a aussi stocké les conservations en coordonnées locales
    set ConsLocal $Conservation
    if {$ConsLocal!=""} {
	regsub -nocase "NoCons"  $ConsLocal "No"  ConsLocal                ;#rR car il serait logique de pouvoir mettre NoConservation 
	regsub -nocase "AllCons" $ConsLocal "All" ConsLocal                ;#rR car il serait logique de pouvoir mettre AllConservation 
	if {[regexp -nocase {^(Iden|Simi|Cons|No)} $ConsLocal Match]} {
	    set ConsLocal "[string totitle $Match]Local"
	} else {
	    set ConsLocal "AllLocal" 
	}
    }

    if {$AllOrA==""} { set AllOrA "All" }

    #rR WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM WM
    if {$GetWhat=="WM"} {
	set LaSortie {}
	set AllA $AllOrA
	if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
	foreach A $AllA {
	    set NbW [MSP Mut $A All-WCount]
	    set NbM [MSP Mut $A All-MCount]
	    lappend LaSortie [format "%s   %2d %2d" $A $NbW $NbM]
	}
	if {$Action=="GetAsText"} { return [join $LaSortie "\n"] }
	return [AfficheListe $LaSortie "" $GetWhat]
    }


    #rR Types Types Types Types Types Types Types Types Types Types Types Types Types Types Types
    set LaSortie {}
    foreach Type [AAType Types] {
	set M 0
	set NbW 0
	set NbM 0
	set Size 0
	set Compo ""
	foreach A [AAType $Type] {
	    incr Size
	    incr NbW [MSP Mut $A All-WCount]
	    incr NbM [MSP Mut $A All-MCount]
	    append Compo $A
	}
	set PcW [expr $NbW/$Size]
	set PcM [expr $NbM/$Size]
	lappend LaSortie [format "%2d %2d %-10s %-6s" $NbW $NbM $Type $Compo]
    }
    if {$GetWhat=="Types"} {
	if {$Action=="GetAsText"} { return [join $LaSortie "\n"] }
	return [AfficheListe $LaSortie "" "Types"]
    } 

    #rR Modules Modules Modules Modules Modules Modules Modules Modules Modules Modules Modules 
    set LaSortie {}
    if {[info exists NbMutIn]} { array unset NbMutIn }
    set AllA $AllOrA
    if {$AllOrA=="All"} { set AllA [MSP Syn ListOf A] }
    foreach A $AllA {
	foreach Name [lsort [MspModule $A ListOf Name]] {
	    if { ! [info exists NbMutIn($Name)]} { set NbMutIn($Name) 0 ; set MutIn($Name) {}}
	    foreach Pos [lsort -unique [MSP Mut $A ListOfPos]] {
		foreach Deb [MspModule $A $Name Deb] Fin [MspModule $A $Name Fin] {
		    if {$Deb<=$Pos && $Pos<=$Fin} {
			incr NbMutIn($Name)
			lappend MutIn($Name) $A
		    }
		}
	    }
	}
    }
    foreach K [lsort [array names NbMutIn]] {
	set V $NbMutIn($K)
	set As {}
	set AAListe ""
	if {$AllOrA=="All" && $NbMutIn($K)>0} {
	    set As [lsort -unique $MutIn($K)]
	    set AAListe "([join $As {}])"
	}
	lappend LaSortie [format "%3d %s" $V "mutations in $K $AAListe"]
    }
    set LaSortie [lsort -decreasing $LaSortie]
    if {$GetWhat=="Modules"} {
	if {$Action=="GetAsText"} { return [join $LaSortie "\n"] }
	return [AfficheListe $LaSortie "" "Modules_${AllOrA}"]
    } 

    #rR FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM FromWtoM 
    set LaSortie {}
    set LesStat  {}
    if {[regexp -nocase "Alpha" $Order]} {
	set LesL [MSP All ListOf A]
    } else { 
	set LesL [AAType ListOfA]
    }
    set LesC $LesL
    lappend LesC "X"

    set LaLigne3L {}
    set LaLigne   {}

    lappend LaLigne3L "     "
    lappend LaLigne   " "

    lappend LaLigne3L "      "
    if {$AllOrA=="All"} {
	lappend LaLigne " -All-   "
    } else {
	set System [MSP Syn $A System]
	set Mut3L [Mut3L $A]
	lappend LaLigne "[format " %-5s" $System]   "
    }
    foreach C $LesC {
	set T [string totitle [UT $C]]
	if {$C=="X"} { set T " * " }
	lappend LaLigne3L " $T"
	lappend LaLigne   "   $C"
    }
    lappend LaSortie [join $LaLigne3L ""]
    lappend LaSortie [join $LaLigne ""]

    set LaLigne [list "          "]
    foreach C $LesC {
	if {$ConsLocal!=""} {
	    set MCount 0
	    set AllA $AllOrA
	    if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
	    foreach A $AllA {
		foreach L [MSP All ListOf A] {
		    foreach PosMut [MSP Mut $A $L$C-Pos] {
			foreach PosCon [MSP Con $A $ConsLocal] {
			    if {0 && $A=="A"} { Espionne "$C $A $L $PosMut $PosCon $ConsLocal" } 
			    if {$PosMut==$PosCon} { incr MCount }
			}
		    }
		}
	    }
	} else {
	    set MCount [MSP Mut $AllOrA $C-MCount]
	    if {$MCount==""} { set MCount 0 }
	}
	lappend LaLigne [format "%4d" $MCount]
    }
    lappend LaSortie [join $LaLigne ""]
    set LaLigne {}
    foreach L $LesL {
	set T [string totitle [UT $L]]
	set LaLigne [list "$T  $L"]
	if {$ConsLocal!=""} {
	    set WCount 0
	    set AllA $AllOrA
	    if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
	    foreach A $AllA {
		foreach C $LesC {
		    foreach PosMut [MSP Mut $A $L$C-Pos] {
			foreach PosCon [MSP Con $A $ConsLocal] {
			    if {$PosMut==$PosCon} { incr WCount }
			}
		    }
		}
	    }
	} else {
	    set WCount [MSP Mut $AllOrA $L-WCount]
	}
	if {$WCount==""} { set WCount 0 }
	lappend LaLigne [format "%4d" $WCount]
	foreach C $LesC {
	    set T "    "
	    if {$ConsLocal!=""} {
		set NbCons 0
		set AllA $AllOrA
		if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
		foreach A $AllA {
		    foreach PosMut [MSP Mut $A $L$C-Pos] {
			foreach PosCon [MSP Con $A $ConsLocal] {
			    if {$PosMut==$PosCon} {
				incr NbCons
				if { ! [info exists MemoNbConsMut($A)]} { set MemoNbConsMut($A) 0 }
				incr MemoNbConsMut($A)
			    }
			}
		    }
		}
		if {$NbCons!=0} { set T [format "%4d" $NbCons] }
	    } else {
		if {$L!=$C} {
		    set WMCount [MSP Mut $AllOrA $L$C-Count]
		    if {$WMCount!=""} {	set T [format "%4d" $WMCount] }
		}	    
	    }
	    lappend LaLigne $T
	}
	lappend LaSortie [join $LaLigne ""]
    }
    lappend LaSortie ""
    set AllA $AllOrA
    if {$AllOrA=="All"} { set AllA [MSP All ListOf A] }
    foreach A $AllA {
	set Systeme [MSP Syn $A System]
	set SeqLength [MSP Syn $A SeqLength]
	if {$SeqLength==""} { continue }
	set NbMut [llength [MSP Mut $A ListOfPos]]
	set PcMut [format %4.1f [expr (100.*$NbMut)/$SeqLength]]
	if {$ConsLocal=="AllLocal"} {
	    set NbConsTot [llength [MSP Con $A $ConsLocal]]
	    set PcConsTot [expr (100*$NbConsTot)/$SeqLength]
	    if {[info exists MemoNbConsMut($A)]} { set NbConsMut $MemoNbConsMut($A) } else { set NbConsMut 0 }
	    set PcConsMut "-"
	    if {$NbConsTot>0} { set PcConsMut [format %4.1f [expr (100.*$NbConsMut)/$NbConsTot]] }
	    lappend LesStat "[format %-5s $Systeme] SeqLength:[format %4d $SeqLength] NbConsTot:[format %3d $NbConsTot] ([format %2d $PcConsTot]%) NbMut:[format %2d $NbMut] ($PcMut%) NbConsMut:$NbConsMut ($PcConsMut%)"
	} else {
	    lappend LesStat "[format %-5s $Systeme] SeqLength:[format %4d $SeqLength] NbMut:$NbMut"
	}
    }
    LConcat LaSortie $LesStat 
    if {$Action=="GetAsText"} { return [join $LaSortie "\n"] }
    return [AfficheListe $LaSortie "" "FromWtoM_${AllOrA}_${Conservation}_${Order}"]
}

proc MSP {{Qui ""} {Quoi ""} {Quid ""}} {
    #rR On regroupe ici toutes les infos sur les Syn les Mut, les Con, les Dis
    #rR Attention pour avoir la liste des AA il faut faire  MSP All ListOf A   (et non pas Syn ou Mut)
    global MSP

    set FichierMemo "[MiSynPatDir]/MSP_Memo.txt"
    if {[regexp -nocase "^ReDo_" $Qui]} {
	if {[file exists $FichierMemo]} {
	    file delete $FichierMemo
	    if {[info exists MSP("EstCharge")]} { unset MSP }
	}
	regsub -nocase "^ReDo_" $Qui "" Qui
	return [MSP $Qui $Quoi $Quid]
    }

    if {[info exists MSP($Qui,$Quoi,$Quid)]} { return $MSP($Qui,$Quoi,$Quid) }
    if {[info exists MSP("EstCharge")]} { return "" }
    set MSP("EstCharge") 1

    if {[file exists $FichierMemo]} {
	array set MSP [ContenuDuFichier $FichierMemo]
	return [MSP $Qui $Quoi $Quid]
    }

    CanalSql [ConnInfoForDatabase MiSynPat]

    set LesDis [SqlExec "select pk_disease,sdisease,ldisease,omim from disease" "GetList"]
    foreach {PkD SDis LDis Omim} $LesDis {
	set MSP(Dis,$PkD,pkd)  $PkD
	set MSP(Dis,$PkD,sdis) $SDis
	set MSP(Dis,$PkD,ldis) $LDis
	set MSP(Dis,$PkD,omim) $Omim
	lappend MSP(Dis,ListOf,pkd)  $PkD
	lappend MSP(Syn,ListOf,ldis) $LDis
    }

    set LesSyn [SqlExec "select pk_synthetase,sName,accession from synthetase" "GetList"]
    foreach {PkS SName Accession} $LesSyn {
	set System [string toupper $SName]
	set A [string index $System 0]
	set MSP(Syn,$A,System) $System
	set MSP(Syn,$A,pk) $PkS
	set MSP(Syn,$A,A) $A
	set MSP(Syn,$A,Accession) $Accession
	set MSP(Syn,$PkS,A) $A
	set MSP(Syn,$PkS,Accession) $Accession
	set MSP(Syn,$System,A) $A
	set MSP(Syn,$System,System) $System
	set MSP(Syn,$System,Accession) $Accession
	set MSP(Syn,$Accession,A)      $A
	set MSP(Syn,$Accession,pk)     $PkS
	set MSP(Syn,$Accession,System) $System
	lappend MSP(Syn,ListOf,A)  $A
	lappend MSP(Syn,ListOf,pk) $PkS
	lappend MSP(Syn,ListOf,System) $System
	lappend MSP(Syn,ListOf,Accession) $Accession
    }
    set MSP(All,ListOf,A) $MSP(Syn,ListOf,A)
    lappend MSP(All,ListOf,A) "Q"
    set MSP(All,ListOf,A) [lsort -unique $MSP(All,ListOf,A)]

    set MSP(Mut,All,ListOfAV1) {}
    set MSP(Mut,All,ListOfAV2) {}
    set MSP(Mut,All,ListOfW) {}
    set MSP(Mut,All,ListOfM) {}
    #rR a mis All au lieu de Syn
    foreach A $MSP(All,ListOf,A) {
	set MSP(Mut,$A,ListOfW)   {}
	set MSP(Mut,$A,ListOfM)   {}
	set MSP(Mut,$A,ListOfPos) {}
	set MSP(Mut,$A,All-WCount) 0
	set MSP(Mut,$A,All-MCount) 0
	set MSP(Mut,All,All-WCount) 0
	set MSP(Mut,All,All-MCount) 0
	foreach B $MSP(All,ListOf,A) {
	    set MSP(Mut,$A,$B-WCount) 0
	    set MSP(Mut,$A,$B-MCount) 0
	}
    }
    set LesMut [SqlExec "select * from mutation order by pk_mutation" "GetList"]
    foreach {PkM PkB PkD PkS V1 V2 Comment} $LesMut {
	set A $MSP(Syn,$PkS,A)
	lappend MSP(Mut,ListOf,A) $A
	lappend MSP(Mut,$A,ListOfV1) $V1
	lappend MSP(Mut,$A,ListOfV2) $V2
	lappend MSP(Mut,$A,ListOfCo) $Comment
	lappend MSP(Mut,All,ListOfV1) $V1
	lappend MSP(Mut,All,ListOfV2) $V2
	lappend MSP(Mut,All,ListOfAV1) "$A $V1"
	lappend MSP(Mut,All,ListOfAV2) "$A $V2"
	lappend MSP(Mut,All,ListOfCo) $Comment
	set MSP(Mut,$PkM,pkd) $PkD
	foreach V [list $V1 $V2] {
	    if { ! [info exists DejaVu($V)] && ! [regexp "XXXXXX" $V] && [regexp {^([A-Z])([0-9]+)([A-Z])$} $V Match W Pos M] } {
		set DejaVu($V) 1
		lappend MSP(Mut,$A,ListOfW) $W
		lappend MSP(Mut,$A,ListOfM) $M
		lappend MSP(Mut,$A,ListOfPos) $Pos
		lappend MSP(Mut,All,ListOfW) $W
		lappend MSP(Mut,All,ListOfM) $M
		lappend MSP(Mut,All,ListOfPos) $Pos
		incr MSP(Mut,$W,All-WCount)
		incr MSP(Mut,$M,All-MCount)
		incr MSP(Mut,$A,$W-WCount)
		incr MSP(Mut,$A,$M-MCount)
		incr MSP(Mut,$A,$W$M-Count)
		incr MSP(Mut,All,$W-WCount)
		incr MSP(Mut,All,$M-MCount)
		incr MSP(Mut,All,$W$M-Count)
		lappend MSP(Mut,$A,$W$M-Pos) $Pos 
	    }
	}
	set MSP(Mut,$A,ListOfWunique) [lsort -unique $MSP(Mut,$A,ListOfW)]
	set MSP(Mut,$A,ListOfMunique) [lsort -unique $MSP(Mut,$A,ListOfM)]
    }
    set MSP(Mut,All,ListOfW) [lsort -unique $MSP(Mut,All,ListOfW)]
    set MSP(Mut,All,ListOfM) [lsort -unique $MSP(Mut,All,ListOfM)]
    set MSP(Mut,ListOf,A)    [lsort -unique $MSP(Mut,ListOf,A)]

    #rR j'ai mis All au lieu de Mut pour la liste
    foreach A $MSP(All,ListOf,A) {
	if { ! [info exists MSP(Mut,$A,ListOfW)]}   { set MSP(Mut,$A,ListOfW)   {} }
	if { ! [info exists MSP(Mut,$A,ListOfM)]}   { set MSP(Mut,$A,ListOfM)   {} }
	if { ! [info exists MSP(Mut,$A,ListOfPos)]} { set MSP(Mut,$A,ListOfPos) {} }
	set MSP(Mut,$A,ListOfW)   [lsort -unique $MSP(Mut,$A,ListOfW)]
	set MSP(Mut,$A,ListOfM)   [lsort -unique $MSP(Mut,$A,ListOfM)]
	set MSP(Mut,$A,ListOfPos) [lsort -unique $MSP(Mut,$A,ListOfPos)]
    }
    foreach Nom [ListeDesPABs] {
	set A [ExtraitInfo $Nom A]
	set MSP(Syn,$A,Nom) $Nom 
	foreach Cons [list IdenGlob ConsGlob SimiGlob AllGlob IdenLocal ConsLocal SimiLocal AllLocal] {
	    set MSP(Con,$A,$Cons) {}
	}
	set MSP(Syn,$Nom,A) $A 
	set MonAccess "${A}mito_Homo.sapi"
	set MSP(Syn,$A,MonAccess) $MonAccess
	set LesConservations [MSPFroMac $Nom Cons-T80 $MonAccess]
	foreach Ligne $LesConservations {
	    lassign $Ligne coords Coords ftype FType fstart FStart fstop FStop fcolor FColor fscore FSCore fnote FNote
	    lappend MSP(Con,$A,$FNote) $FStart 
	}
	set MSP(Con,$A,AllGlob) {}
	foreach Cons [list IdenGlob ConsGlob SimiGlob] {
	    LConcat MSP(Con,$A,AllGlob) $MSP(Con,$A,$Cons)
	}
	set MSP(Con,$A,AllGlob) [lsort -unique -integer $MSP(Con,$A,AllGlob)]
	foreach Cons [list IdenGlob ConsGlob SimiGlob AllGlob] {
	    regsub "Glob" $Cons "Local" Loca 
	    set MSP(Con,$A,$Cons) [lsort -integer $MSP(Con,$A,$Cons)]
	    if {[info exists EstGlo]} { unset EstGlo ; set EstGlo(bidon) 1 }
	    foreach Pos $MSP(Con,$A,$Cons) {
		set EstGlo($Pos) 1
	    }
	    set Seq [MSPFroMac $Nom Sequences $MonAccess]
	    set MSP(Syn,$A,SeqWithGap) $Seq
	    regsub -all -nocase {[^a-z]} $Seq "" SeqWithoutGap
	    set MSP(Syn,$A,SeqWithoutGap) $SeqWithoutGap
	    set L 0
	    set G 0
	    if {0 && $A=="A" && $Cons=="IdenGlob"} {
		Espionne $MonAccess
		Espionne $Seq
		Espionne [string length $Seq]
	    }  
	    foreach C [split $Seq ""] {
		incr G
		if {$C!="-" && $C!="."} { incr L ; if {$A=="A" && $Cons=="IdenGlob"} {  Espionne "=$C= $L" } }
		if {[info exists EstGlo($G)]} { lappend MSP(Con,$A,$Loca) $L }
	    }
	}
	set LesPos {}
	set SeqLength [string length [QueLaSequenceDuFichierTFA "[RepertoireDuGenome]/prottfa/$Nom"]]
	set MSP(Syn,$A,SeqLength) $SeqLength
	foreach i [NombresEntre 1 $SeqLength] {
	    lappend LesPos $i
	} 
	set MSP(Con,$A,NoLocal) [ListsComplement $LesPos $MSP(Con,$A,AllLocal)]
    }
    CanalSqlDisconnect

    Sauve [array get MSP] dans $FichierMemo

    return [MSP $Qui $Quoi $Quid]
}

proc AAType {{Qui ""}} {
    global AAType

    if {[info exists AAType($Qui)]} { return $AAType($Qui) }
    if {[info exists AAType("EstCharge")]} { return "" }

    set AAType(aliphatic)  [list I L M V]
    set AAType(aromatic)   [list F Y W]
    set AAType(acidic)     [list D E Q N]
    set AAType(basic)      [list H K R]
    set AAType(scmall)     [list P A G S T]
    set AAType(cystein)    [list C]
    foreach K [lsort [array names AAType]] {
	set V $AAType($K)
	lappend AAType(Types) $K
	foreach A $V {
	    lappend AAType(ListOfA) $A
	    set AAType($A) $K
	}
    }
    set Ordonnes {}
    set AAType(AlphabeticListOfAA) [lsort $AAType(ListOfA)]
    set AAType("EstCharge") 1
    return [AAType $Qui]
}
proc SeqCalagePourTous {} {
    foreach Nom [ListeDesPABs] {
	Espionne [SeqCalage $Nom]
    }
}

proc SeqCalage {Nom} {
    set Tfa "" ; set FiTfa [GscopeFile $Nom prottfa]
    set Hit "" ; set FiHit [GscopeFile $Nom prottfa_besthumanhit]
    set Acc "" ; set FiAcc [GscopeFile $Nom prottfa_access]
    if {[FileExists $FiTfa]} { set Tfa [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiTfa]]] }
    if {[FileExists $FiHit]} { set Hit [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiHit]]] }
    if {[FileExists $FiAcc]} { set Acc [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiAcc]]] }
    set OkHit [string equal $Tfa $Hit]
    set OkAcc [string equal $Tfa $Acc]
    set InHit [string first $Tfa $Hit]
    set InAcc [string first $Tfa $Acc]
    if {$OkHit} { return 1; [FaireLire "$Nom Ok. Les séquences sont pile-poil égales !"] }
    set LesParties [list 2 3 4]
    foreach Part $LesParties {
	set MTfa [expr [string length $Tfa]/$Part]
	set Bout [string range $Tfa $MTfa $MTfa+9]
	set MHit [string first $Bout $Hit]
	set XTfa [string first $Bout $Tfa]
	if {$MHit>=0} { break }
    }
    if {$MHit>=0} {
	set NbDecal [expr $MTfa - $MHit]
	if {$NbDecal<0} {
	    set N [expr -$NbDecal]
	    set Decal [string repeat " " $N]
	    set NewTfa "$Decal$Tfa"
	    set NewHit $Hit
	} else {
	    set Decal [string repeat " " $NbDecal]
	    set NewHit "$Decal$Hit"
	    set NewTfa $Tfa
	}
	set X ""
	foreach CTfa [split $NewTfa ""] CHit [split $NewHit ""] {
	    if {$CTfa!=$CHit} {
		append X "X"
	    } else {
		append X " "
	    }
	}

	return [Affiche "$NewTfa\n$NewHit\n$X" "GrandeLargeur" "$Nom"]
    }
    return [SeeAby "blast_myself" $Nom] 

}

proc MakeBlastDatabaseForEachProttfa {} {
    file mkdir "[RepertoireDuGenome]/banques_myself"
    NousAllonsAuBoulot "[RepertoireDuGenome]/prottfa"
    foreach Nom [ListeDesPABs] {
	exec formatdb -p T -i $Nom 
	foreach P [glob -nocomplain "$Nom.*"] {
	    Espionne $P
	    file rename $P "[RepertoireDuGenome]/banques_myself/$P"
	}
    }
    OnRevientDuBoulot
}


proc CompareLesSequencesPourMisynpat {} {

    set Dir "[RepertoireDuGenome]/blastp_myself"
    file mkdir $Dir
    NousAllonsAuBoulot $Dir
    foreach Nom [ListeDesPABs] {
	set Tfa "" ; set FiTfa [GscopeFile $Nom prottfa]
	set Hit "" ; set FiHit [GscopeFile $Nom prottfa_besthumanhit]
	set Acc "" ; set FiAcc [GscopeFile $Nom prottfa_access]
	if {[FileExists $FiTfa]} { set Tfa [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiTfa]]] } else { FaireLire "$Nom pas tfa" }
	if {[FileExists $FiHit]} { set Hit [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiHit]]] } else { FaireLire "$Nom pas hit" }
	if {[FileExists $FiAcc]} { set Acc [string toupper [QueLaSequenceDuTexteTFA [ContenuDuFichier $FiAcc]]] } else { FaireLire "$Nom pas acc" }
	set OkHit [string equal $Tfa $Hit]
	set OkAcc [string equal $Tfa $Acc]
	set InHit [string first $Tfa $Hit]
	set InAcc [string first $Tfa $Acc]
	if {"$OkHit $OkAcc $InHit $InAcc"=="1 1 0 0"} { continue }
	Espionne "$Nom $OkHit $OkAcc $InHit $InAcc [string length $Tfa] [string length $Hit] [string length $Acc]"
	if { [FileExists $FiHit] && ! $OkHit } {
	    Espionne "blastall -p blastp -i $FiHit -d [RepertoireDuGenome]/banques_myself/$Nom -F F -o $Nom"
	    exec blastall -p blastp -i $FiHit -d [RepertoireDuGenome]/banques_myself/$Nom -o $Nom
	}
	if { 0 && [FileExists $FiAcc] && ! $OkAcc } {
	    Espionne "blastall -p blastp -i $FiAcc -d [RepertoireDuGenome]/banques_myself/$Nom -o $Nom"
	    exec blastall -p blastp -i $FiAcc -d "[RepertoireDuGenome]/banques_myself/$Nom"
	}
    }
    OnRevientDuBoulot
}

proc InformeBestHumanHitPourTous {} {
    FaireLire "Attention ce n'est normalement pas à refaire ..."
    file mkdir "[RepertoireDuGenome]/prottfa_besthumanhit"
    file mkdir "[RepertoireDuGenome]/protembl_besthumanhit"
    set LaSortie {}
    foreach Nom [ListeDesPABs] {
	set BestHumanHit [BestHumanHit $Nom]
	Espionne "$Nom $BestHumanHit"
	InformeSansDemander $Nom "=BestHumanHit20170113: $BestHumanHit"
	set EMBL [QGQ UniprotData $BestHumanHit]
	set FicTfa  [Sauve [SequenceFormatTFA $EMBL] dans [GscopeFile $Nom "prottfa_besthumanhit"]]
	set FicEmbl [Sauve $EMBL dans [GscopeFile $Nom "protembl_besthumanhit"]]
	lappend LaSortie $FicEmbl
    }
    return $LaSortie
}

proc BestHumanHit {Nom} {
    lappend LesVoulus "SY[NomDeMSP $Nom A]M_HUMAN"
    lappend LesVoulus "SY[NomDeMSP $Nom A]_HUMAN"
    foreach Voulu $LesVoulus {
	foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "blastp"]] {
	    if { ! [regexp {^>([^ ]+) } $Ligne Match BAI]} { continue }
	    set Access [lindex [split $BAI "|"] end]
	    if {$Access=="$Voulu"} { return $Access }
	}
    }
    set LesPossibles {}
    set Max 55
    foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "blastp"]] {
	if {[incr Max -1]==0} { break }
	if { ! [regexp {>([^ ]+) } $Ligne Match BAI]} { continue }
	set Access [lindex [split $BAI "|"] end]
	if {[regexp "_HUMAN$" $Access]} { return $Access }
	lappend LesPossibles $Access  
    }
    return [ChoixParmi $LesPossibles]
}

proc NomDeMSP {{Qui ""} {Quoi ""}} {
    global NomDeMSP

    if {$Quoi==""} { set Quoi "Nom" }

    set Qui  [string touppe $Qui]
    set Quoi [string touppe $Quoi]
    regsub -all "_" $Qui " " Qui

    if {[info exists NomDeMSP($Qui,$Quoi)]} { return $NomDeMSP($Qui,$Quoi) }
    if {[info exists NomDeMSP("EstCharge")]} {
	if {[info exists NomDeMSP($Qui,NOM)]} {
	    set Nom $NomDeMSP($Qui,NOM)
	    if {[info exists NomDeMSP($Nom,$Quoi)]} { return $NomDeMSP($Nom,$Quoi) }
	}
	return ""
    }
    set NomDeMSP("EstCharge") 1

    set NomDeMSP(LISTOF,KEY) [list A AAA System Definition Nom]
    foreach Nom [ListeDesPABs] {
	set A [ExtraitInfo $Nom A:] 
	set AAA [ExtraitInfo $Nom AAA:] 
	set SYSTEM [ExtraitInfo $Nom System:] 
	set DEFINITION [ExtraitInfo $Nom Definition:]
	set NOM $Nom
	foreach K $NomDeMSP(LISTOF,KEY) {
	    set K [string toupper $K]
	    set NomDeMSP($Nom,$K) [set $K]
	    set NomDeMSP([string toupper [set $K]],NOM) $Nom
	    lappend NomMSP(LISTOF,$K) [set $K]
	}
    }
    return [NomDeMSP $Qui $Quoi]
}

proc InformeMSP {} {
    CanalSql [ConnInfoForDatabase MiSynPat]
    set LaSortie {}
    foreach Nom [ListeDesPABs] {
	set Entete [EnteteDuFichierTFA [GscopeFile $Nom prottfa]]
	scan $Entete "%s %s %s %s %s %s" N Systeme A D1 D2 Access
	InformeSansDemander $Nom "=System: $Systeme"
	InformeSansDemander $Nom "=A: $A"
	InformeSansDemander $Nom "=AAA: [string totitle [UT $A]]"
	InformeSansDemander $Nom "=Definition: $D1 $D2"
	InformeSansDemander $Nom "=Access: $Access"
	set LesLignesEMBL [LaSequenceDesBanques $Access]
	if {$LesLignesEMBL!={}} { 
	    DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX SequenceNarcisse
	    InformeSansDemander $Nom "=Narcisse_ID: $ID"
	    InformeSansDemander $Nom "=Narcisse_AC: $AC"
	    InformeSansDemander $Nom "=Narcisse_DE: $DE"
	    InformeSansDemander $Nom "=Narcisse_GN: $GN"
	    set EnteteNarcisse ">$Nom $Access $A $D1 $D2 $Systeme"
	    lappend LaSortie [Sauve [SequenceFormatTFA $SequenceNarcisse $EnteteNarcisse protbrut] dans [GscopeFile $Nom prottfa_access]]
	}
    }
    return $LaSortie
}

proc MSPFroMac args {
    JeMeSignale
    if {[PourWscope]} { return [FromMacsim {*}$args] }
    set Commande "ret FromMacsim [join $args { }]"
    set Res [QuestionDeScience MSP $Commande]
    return $Res
}

proc FroMac args {
    if {[PourWscope]} { return [FromMacsim {*}$args] }
    set Commande "ret FromMacsim [join $args { }]"
    set Res [QuestionDeScience Zero $Commande]
    return $Res
}

proc CreateProjectMSP {} {
    FaireLire "Attention tout est déjà fait. A manipuler avec précautions"
    CanalSql [ConnInfoForDatabase MiSynPat]
    set XmlDir "[MiSynPatDir]/data/alignments"
    foreach XmlFic [lsort [glob -nocomplain "$XmlDir/*_WithModules.xml"]] {
	Espionne $XmlFic
	exec ln -sf $XmlFic [RepertoireDuGenome]/macsimXml_Ori/MSP
	set LesNames [FroMac $XmlFic ListOfNames]
	set Moi ""
	foreach Name $LesNames {
	    if {[regexp {^([A-Z])mito_Homo.sapi$} $Name Access A]} { set Moi $Name ; break }
	}
	if {$Moi==""} { FaireLire "Je ne trouve pas $Access"; continue }
	set SeqGap [FroMac $XmlFic Sequences $Access]
	regsub -all {\.} $SeqGap "" Seq
	set R [SqlExec "select sName, lName, accession, class from synthetase where sname like '$A%'" "GetList"]
	lassign $R Systeme Definition Access Class
	set Entete "$Systeme $A $Definition $Access"
	set TFA [SequenceFormatTFA $Seq $Entete "protbrut"]
	Espionne $TFA
#	Sauve $TFA dans "/genomics/link/MSP/DeMisynpat/$Systeme.tfa"
    }
}

proc TestMSP {} {
    set YaCons 0
    set LesStart {}
    foreach Ligne [LesLignesDuFichier "[HomeRipp]/msp/data/alignments/dcethal1.txt"] {
	if {$YaCons && [regexp {<fstart>([0-9]+)</fstart>} $Ligne Match Start]} {
	    lappend LesStart $Start
	    set YaCons 0
	    continue 
	}
	if {[regexp {<ftype>Cons\-T80</ftype>} $Ligne]} { set YaCons 1 ; continue }
    }
    set LesStart [lsort -integer $LesStart]
    Espionne $LesStart
    exit
}
 
proc MiSynPatMajDisease {{DoIt ""}} {
    set Fichier "[MiSynPatDir]/disease20151104.csv"

    set DoIt [string equal -nocase $DoIt "DoIt"]

    CanalSqlMiSynPat

    set LesPkModifies {}
    foreach Ligne [LesLignesDuFichier $Fichier] {
	lassign [split $Ligne ";"] pk sd ld om or
	regsub -all "#"  $om " " om
	regsub -all { +} $om " " om
	set om [string trim $om]
	if { ! [regexp {^[0-9]+$} $pk] } { continue }
	set LesLus [SqlExec "select * from disease where pk_disease=$pk" "GetList"]
	lassign $LesLus pkLu sdLu skLu omLu orLu
	if {$sd!=$sdLu} {
	    Espionne $Ligne
	    Espionne $LesLus
	    set Sql "update disease set sdisease='$sd' where pk_disease=$pk"
	    Espionne $Sql
	    if {$DoIt} { SqlExec $Sql }
	    lappend LesPkModifies $pk
	}  
	if {$om!=$omLu} {
	    Espionne $Ligne
	    Espionne $LesLus
	    set Sql "update disease set omim='$om' where pk_disease=$pk"
	    Espionne $Sql
	    if {$DoIt} { SqlExec $Sql }
	    lappend LesPkModifies $pk
	}  
    }
    CanalSqlDisconnect
    if { ! $DoIt } {
	Espionne "*****************************************************************"
	Espionne "* Attention run 'MiSynPatMajDisease DoIt' if you want to update *"
	Espionne "*****************************************************************"
	return "I_did_nothing_for_the_moment"
    }
    return $LesPkModifies
}

proc SortByStart {A B} {
    scan $A "%s %d" BidonA StartA
    scan $B "%s %d" BidonB StartB
    if {$StartA<$StartB} { return -1 }
    if {$StartA>$StartB} { return  1 }
    return 0
}

proc MiSynPatDir {} {
    return "[HomeRipp]/wwwLinux/MiSynPat"
}

#rR pour les StructuralModules : 
#rR  1/ Marie met à jour le fichier Excel StructuralModules.xlsx
#rR  2/ je le sauve en .csv
#rR  3/ MiSynPatStructuralModulesAsFeatures crée les .feat
#rR  4/ MiSynPatStructuralModulesForDatabase les met dans la database
#rR  5/ MiSynPatAddStructuralModulesToMacsims les met dans les macsims

proc MiSynPatAddStructuralModulesToMacsims {{Force ""} {Lequel ""}} {
    set Force [string equal -nocase Force $Force]
    set LesNouveaux {}
    foreach FeatFile [lsort [glob -nocomplain "[MiSynPatDir]/data/StructuralModulesFeatures/$Lequel*.feat"]] {
	if { ! [regexp {/[A-Z].feat$} $FeatFile] } { continue }
	set Queue [file tail $FeatFile]
	Espionne $Queue
	set A [file rootname $Queue]
	set MacsimsIn  "[MiSynPatDir]/data/alignments/${A}_WithModules.xml"
	set MacsimsOut "[MiSynPatDir]/data/alignments/${A}_WithModules_new.xml"
	if {[FileAbsent $MacsimsIn] }             { Warne "$MacsimsIn does not exist"  ; continue }
	if {[FileExists $MacsimsOut] && ! $Force} { Warne "$MacsimsOut already exists" ; continue }
	set Reponse [exec ordali $MacsimsIn -exe AddModules $FeatFile]    ;#rR on y rajoute _WithModules
	set Recu [lindex [split $Reponse " "] end]
	Warne "Ordali created $Recu"
	lappend LesNouveaux $Recu
    }
    return $LesNouveaux
}

proc StructuralModuleColor {Qui} {
    global SMC 
    set Qui [string tolower $Qui]
    if {[info exists SMC($Qui)]} { return $SMC($Qui) }
    if {[info exists SMC("EstCharge")]} { return "grey" }
    set SMC("EstCharge") 1
    
    set CM "
brown;C-terminal extension domain
blue;Anticodon Binding domain
green;alpha-helical domain
green;Bacterial-type C-terminal extension
green;TGS domain
green;tRNA edge-binding domain
green;WHEP domain
lightgreen;second additional domain
magenta;Putative MTS
orange;Insertion domain
red;Catalytic domain
cyan;Helix of dimerization
grey;HIGH
grey;KMSKS
grey;motif_1
grey;motif_2
grey;motif_3
"
    regsub -all {[\;\n]+} [string trim $CM "\n;"] ";" CM 
    foreach {C D} [split $CM ";"] {
	set SMC([string tolower [string trim $D]]) $C
    }
    return [StructuralModuleColor $Qui]
}

proc MspModule {{Qui ""} {Quoi ""} {Quid ""}} {
    return [MiSynPatStructuralModulesForDatabase $Qui $Quoi $Quid "GetIt"]
}

proc MiSynPatStructuralModulesForDatabase {{Qui ""} {Quoi ""} {Quid ""} {GetWhat ""}} {
    #rR GetWhat = GetIt  pour avoir les infos
    #rR GetWhat = ShowIt pour voir les commandes sql de mise à jour de la table synthtase.features de MiSynpat.sql
    #rR GetWhat = DoIt   pour mettre à jour la table synthtase.features de MiSynpat.sql
    #rR Attention il faut avoir fait les .feat avec MiSynPatStructuralModulesAsFeatures

    regsub -all " " $Quoi "_" Quoi
    regsub -all " " $Quid "_" Quid

    if {$GetWhat==""} { set GetWhat "GetIt" }
    set GetIt  [string equal -nocase $GetWhat "GetIt"]
    set ShowIt [string equal -nocase $GetWhat "ShowIt"]
    set DoIt   [string equal -nocase $GetWhat "DoIt"]

    package require sqlite3
    set File "[MiSynPatDir]/misynpat.sql"
    set db "root"
    sqlite3 $db $File
    
    set NFs [$db eval {select sName,features from synthetase order by sName}]
    set LesTodo {}
    set LesDone {}
    foreach {N Features} $NFs {
	set A [string index $N 0]
	
	set LesFeatures [split $Features ","]
	set SeqLen [string trim [lindex $LesFeatures 0] "'"]
	set LesFeatures [lrange $LesFeatures 1 end]
	set LesFeatures [lsort -command SortByStart $LesFeatures]
	#rR ici on remplit Module pour le GetIt ................ en partant de sql
	foreach Feature $LesFeatures {
	    regsub -all "'" $Feature "" Feature
	    set LesMots [split $Feature " "]
	    lassign $LesMots Acc Deb Fin Color Name
	    set A [string index $Acc 0]
	    lappend Module($A,Modules,) "$Deb $Fin $Color $Name"
	    lappend Module(ListOf,A,) $A
	    lappend Module(ListOf,Name,) $Name
	}
	#rR ici on prepare les new pour la mise à jour ......... en partant des .feat
	if {$DoIt || $ShowIt} {
	    set LesNews {}
	    foreach Ligne [LesLignesDuFichier "[MiSynPatDir]/data/StructuralModulesFeatures/$A.feat"] {
		if {[regexp "^FEATURE" $Ligne]} { continue }
		set LesMots [split $Ligne ";"]
		lassign $LesMots Acc Loc Deb Fin Color Score Comment
		regsub -all " " $Comment "_" Comment
		set NewFeat "$Acc $Deb $Fin $Color $Comment"
		lappend LesNews $NewFeat	    
	    }
	    set New "'$SeqLen','[join $LesNews ',']'"
	    
	    if {$ShowIt} {
		lappend LesTodo "$db eval {update synthetase set features=$New where sName=$N}"
	    }
	    if {$DoIt} {
		$db eval {update synthetase set features=$New where sName=$N}
		lappend LesDone $Acc
	    }
	}
    }
    if { $ShowIt } { return $LesTodo }
    if { $DoIt   } { return $LesDone }

    #GetIt
    set  Module(ListOf,A,)    [lsort -unique $Module(ListOf,A,)]
    set  Module(ListOf,Name,) [lsort -unique $Module(ListOf,Name,)]
    if {[info exists Module($Qui,$Quoi,$Quid)] } { return $Module($Qui,$Quoi,$Quid) }
    if {[info exists Module($Qui,Modules,)] } {
	foreach Mod $Module($Qui,Modules,) {
	    lassign $Mod Deb Fin Color Name
	    set DF "$Deb-$Fin"
	    regsub -all " " $Name "_" Name
	    set Module($Qui,$Name,Name)  $Name
	    set Module($Qui,$Name,DF)    $DF
	    set Module($Qui,$Name,Deb)   $Deb
	    set Module($Qui,$Name,Fin)   $Fin
	    set Module($Qui,$Name,Color) $Color
	    lappend Module($Qui,ListOf,Name)  $Name
	    lappend Module($Qui,ListOf,DF)    $DF
	    lappend Module($Qui,ListOf,Deb)   $Deb
	    lappend Module($Qui,ListOf,Fin)   $Fin
	    lappend Module($Qui,ListOf,Color) $Color
	    foreach K [list DF Deb Fin Name] {
		set Module($Qui,[set $K],Name)  $Name
		set Module($Qui,[set $K],DF)    $DF
		set Module($Qui,[set $K],Deb)   $Deb
		set Module($Qui,[set $K],Fin)   $Fin
		set Module($Qui,[set $K],Color) $Color
	    }
	}
	if {[info exists Module($Qui,$Quoi,$Quid)]} { return $Module($Qui,$Quoi,$Quid) }
	return ""
    }
    return ""
}

proc MiSynPatStructuralModulesAsFeatures {} {
    #rR On crée les fichiers features qui seront intégrés dans les macsims et dans la base de données
    foreach A [MiSynPatStructuralModules ListOf A] {
	set LesSM {}
	lappend LesSM "FEATURE MODULE PROPAGATE all"
	foreach L [MiSynPatStructuralModules $A Limits] M [MiSynPatStructuralModules $A Domains] {
	    lassign [split $L "-"] D F
	    regsub -all "_" $M " " M
	    set Color [StructuralModuleColor $M]
	    Espionne "$L $D $F $M"
	    lappend LesSM "${A}mito_Homo.sapi;local;$D;$F;$Color;0.0;$M"
	}
	if {[llength $LesSM]==1} { continue }
	set a [string tolower $A]
	set Fichier "${A}.feat"
	lappend LesNouveaux [SauveLesLignes $LesSM dans $Fichier]
    }
    return $LesNouveaux
}

proc MiSynPatStructuralModules {{Qui ""} {Quoi ""}} {
    #rR On lit le fichier Excel de Marie
    #rR Attention je fais quelques petites tricheries pour corriger les incohérences
    #rR Attention on remplace tous les blancs par des _
    global SM
    if {$Qui=="" && $Quoi==""} {
	set LeHelp {}
	set Com "gscope puts"
	if {[PourWscope]} { set Com "qds MSP" }
	lappend LeHelp "Usage with $Com"
	lappend LeHelp "   $Com puts MiSynPatStructuralModules ListOf A"
	lappend LeHelp "   $Com MiSynPatStructuralModules ListOf AAA"
	lappend LeHelp "And for each A ou 3 letters amino acid"
	lappend LeHelp "   $Com MiSynPatStructuralModules Asp class"
	lappend LeHelp "   $Com MiSynPatStructuralModules Asp Domains"
	lappend LeHelp "and for each domain of Asp"
	lappend LeHelp "   $Com MiSynPatStructuralModules Asp Catalytic_domain"
	lappend LeHelp "or"
	lappend LeHelp "   $Com MiSynPatStructuralModules Asp Limits"
	lappend LeHelp "   $Com MiSynPatStructuralModules Asp 208-608"
	return [join $LeHelp "\n"]
    }
    if {[info exists SM($Qui,$Quoi)]} { return $SM($Qui,$Quoi) }
    if {[info exists SM($Qui,I)]} {
	set I $SM($Qui,I)
	if {[info exists SM($I,$Quoi)]} { return $SM($I,$Quoi) }
	return ""
    }
    if {[info exists SM("EstCharge")]} { return "" }
    set SM("EstCharge") 1

    set LesDomainesConnus [list HIGH KMSKS motif_1 motif_2 motif_3 Putative_MTS Anticodon_Binding_domain Catalytic_domain Insertion_domain helix_of_dimerization]

    set Fichier "[MiSynPatDir]/data/StructuralModulesFeatures/StructuralModules.csv"
    LoadTxlWithRowsOfCells $Fichier SM -1 ";"
    foreach I $SM(ListAllPlease,) {
	set A   $SM($I,1_letter_code)
	set AAA $SM($I,3_letters_code)
	lappend SM(ListOf,A) $A
	lappend SM(ListOf,AAA) $AAA
	set SM($A,I)   $I
	set SM($AAA,I) $I
	set SM($I,A)   $A
	set SM($I,AAA) $AAA
	if {$SM($I,HIGH)==""} {
	    set SM($I,class) "I"
	} else {
	    set SM($I,class) "II"
	}
	set SM($I,Limits)  {}                ;#rR attention dans un deuxième temps on changera l'ordre en gardant le parallele Limits Domains
	set SM($I,Domains) {}
	if {[regexp "/" $SM($I,Others)]} { set SM($I,Others) "" }
	if {$SM($I,Others)!=""} {
	    regsub -nocase {SAD *= *ThrRS and AlaRS} $SM($I,Others) "" SM($I,Others)
	    set SM($I,Others) [string trim $SM($I,Others)]
	    set Others $SM($I,Others)
	    set Names  $SM($I,name_of_Others)
	    if {[regexp " and " $Others]} {
		regsub " and " $Others "@" Others
		regsub "omain and " $Names "omain@" Names
		set LesLimites  [split $Others "@"]
		set LesDomaines [split $Names "@"]
	    } else {
		set LesLimites  [list $Others]
		set LesDomaines [list $Names]
	    }
	    set LesD {}
	    foreach D $LesDomaines {
		regsub -all " " $D "_" D
		lappend LesD $D
	    }
	    set LesDomaines $LesD
	    set SM($I,Limits)  $LesLimites
	    set SM($I,Domains) $LesDomaines
	}
	foreach Dom $LesDomainesConnus {
	    if {[regexp "/" $SM($I,$Dom)]} { set SM($I,$Dom) "" }
	    if {$SM($I,$Dom)==""} { continue }
	    lappend SM($I,Limits)  $SM($I,$Dom)
	    lappend SM($I,Domains) $Dom
	}
    }
    foreach I $SM(ListAllPlease,) {
	foreach L $SM($I,Limits) D $SM($I,Domains) {
	    set SM($I,$L) $D
	}
	set SM($I,Limits) [lsort -command SortLimits $SM($I,Limits)]
	set OrderedDomains {}
	set OrderedLimits  {}
	set LesPetits {}
	foreach L $SM($I,Limits) {
#Espionne "$L $SM($I,$L)"
	    lassign [split $L "-"] D F
	    if {$F-$D<12} { lappend LesPetits $L ; continue }
	    lappend OrderedDomains $SM($I,$L)
	    lappend OrderedLimits $L
	}
	foreach L $LesPetits {
	    lappend OrderedDomains $SM($I,$L)
	    lappend OrderedLimits $L
	}
#Espionne $OrderedDomains
#Espionne $OrderedLimits
	set SM($I,Domains) $OrderedDomains
	set SM($I,Limits)  $OrderedLimits
    }
    set SM(Queue,) $SM(Queue)
    return [MiSynPatStructuralModules $Qui $Quoi]
}

proc SortLimits {A B} {
    scan $A "%d" StartA
    scan $B "%d" StartB
    if {$StartA<$StartB} { return -1 }
    if {$StartA>$StartB} { return  1 }
    return 0
}

proc SchemaPFAM {} {
    set LName [list "AARS2" "CARS2" "DARS2" "EARS2" "FARS2" "GARS " "HARS2" "IARS2" "KARS " "LARS2" "MARS2" "NARS2" "PARS2" "RARS2" "SARS2" "TARS2" "VARS2" "WARS2" "YARS2"]
    foreach Name $LName {
	FeaturesdesMacsims $Name
    } 
}

proc FeaturesdesMacsims { Name } {
    global LNOrdali LSOrdali TabSF ListeTypeDeFeatures
    unset -nocomplain LNOrdali LSOrdali TabSF ListeTypesDeFeatures Sequences TDesAccess
    set Fichier "[MiSynPatDir]/misynpat.sql"
    set db "root"
    sqlite3 $db $Fichier
    set Lfeatin [list]	
    set system [string index $Name 0]
    try {
	set fileMacsim "[MiSynPatDir]/data/alignments/${system}_maj.xml"
    } on error {result options} {
	Espionne -options $options $result
	continue
    }
    DecortiqueUnXml2 $fileMacsim
    InitSequences
    InitInfoSeqs
    AssignSeqToGroup
    DonneTabFeature TabSF
    ::global {*}[info globals "TD*"]
    update
    set Lsqn [list] ; set Lseq [list] ; set Lacc [list]
    
    foreach n $LNOrdali s $LSOrdali {
	if {$n eq ""} {continue}

	lappend Lsqn $n
	lappend Lacc [set TDesAccess($n)]
	lappend Lseq $s
    }
    regsub -all {\.} $Lseq {\-} Lseq
    
    set idmito [lsearch -glob -inline $Lsqn "${system}mi*_Homo.sapi"]
    set indexseqmito [lsearch -glob $Lsqn "$idmito"]
    set seqmitoG [lindex $Lseq $indexseqmito]
    set accmito [lindex $Lacc $indexseqmito]
    regsub -all {\-} $seqmitoG {} seqmitoL
    set lenght [string length $seqmitoL]
    lappend Lfeatin "'$lenght'"
    $db eval {update synthetase set accession=$accmito where sName=$Name}
    
    foreach key [array names TabSF "${system}mi*_Homo.sapi,*"] {
	lassign [split $key ,] nom feat
	Espionne $feat
	if {$feat eq "MODULE"} {
	    foreach ft $TabSF($key) {
		DecortiqueUneFeature $ft start stop col score note csys  
		lappend Lfeatin "'$nom $start $stop $col $note'"	
	    }
	}
    }
    set featin [join $Lfeatin ","]
    Espionne $featin
    #$db eval {update synthetase set seq=$featin where sName=$Name}	 
}

proc FeaturesdunMacsims {} {
    global LNOrdali LSOrdali TabSF ListeTypeDeFeatures
    
    #set Names [$db eval {select sName from synthetase}]
    set Name "SARS2" 
    
    # recupere les données MACSIMS	
    set system [string index $Name 0]
    set fileMacsim "[MiSynPatDir]/data/alignments/${system}_maj.xml"
    Espionne "$Name"
    Espionne "$system"
    Espionne "$fileMacsim"
    DecortiqueUnXml2 $fileMacsim
    InitSequences
    InitInfoSeqs
    AssignSeqToGroup
    DonneTabFeature TabSF
    global {*}[info globals "TD*"]
    
    foreach key [array names TabSF "${system}mi*_Homo.sapi,*"] {
	lassign [split $key ,] nom feat
	Espionne $feat
	if {$feat eq "PFAM-A"} {
	    foreach ft $TabSF($key) {
		DecortiqueUneFeature $ft start stop col score note csys  
		Espionne "$nom : $start $stop $col $note,"	
	    }
	}
    }	
}


proc SequencesDesVeryLast {} {
    global LNOrdali LSOrdali TabSF ListeTypeDeFeatures
    
    set Fichier "[MiSynPatDir]/misynpat.sql"
    set db "root"
    sqlite3 $db $Fichier
    
    #set Names [$db eval {select sName from synthetase}]
    set Names [list "GARS" "KARS"] 
    
    foreach Name $Names { 
	
	# recupere les données MACSIMS	
	set system [string index $Name 0]
	set fileMacsim "[HomeRipp]/wwwLinux/misynpat/data/alignments/${system}_maj.xml"
	Espionne "$Name"
	Espionne "$system"
	Espionne "$fileMacsim"
	DecortiqueUnXml2 $fileMacsim
	InitSequences
	InitInfoSeqs
	AssignSeqToGroup
	DonneTabFeature TabSF
	global {*}[info globals "TD*"]
	set Lsqn [list] ; set Lseq [list] ; set Lacc [list]
	
	foreach n $LNOrdali s $LSOrdali {
	    if {$n eq ""} {continue}

	    lappend Lsqn $n
	    lappend Lacc [set TDesAccess($n)]
	    lappend Lseq $s
	}
	
	
	set idmito [Lsearch -glob -inline $Lsqn "${system}mi*_Homo.sapi"]
	set indexseqmito [Lsearch -glob $Lsqn "$idmito"]
	set accmito [lindex $Lacc $indexseqmito]
	set seqmitoG [lindex $Lseq $indexseqmito]
	regsub -all {\.} $seqmitoG {} seqmitoL
	
	
    }
}

proc InitDBMisynpat {} {
    package require sqlite3
    LesDefauts Mode batch
    set table "	
       	- synthetase {
           . pk_synthetase P
           . sName V5
           . lName V40
           . accession V16
           . dateMod V10
           . class V1
           . seq T
        }
	- biblio {
           . pk_biblio P
           . pmid V16
	   . accepted I -1 : pas vu ; 0 refuse ; 1 accepte
	   . abstract T
	   . sJournal V64
	   . auteurs T
		   . pages V10
		   . datem V10
		   . datey V10
		   . titre T
           . volume V4
		   
        }
		- mutation {
           . pk_mutation P
		   . pk_biblio I
		   . pk_disease I
		   . pk_synthetase I
           . variant1 V16
		   . variant2 V16
        }
		- disease {
           . pk_disease P
		   . sdisease V16
		   . ldisease T
		   . omim V10
		   . organs T
        }
		- ln_biblio_synthetase {
            . pk_biblio I
			. pk_synthetase I
        }
		- ln_disease_synthetase {
           . pk_disease I
		   . pk_synthetase I
                }
		- structure {
           . pk_structure P
           . pk_synthetase I
		   . id V4 NULL if model from PHYRES2
           . seqname V32 
		   . pcid R identity percent with human mito 
             }
		
		"

    
    set FichierSql "./misynpat.sql"
    if {[file exists $FichierSql]} { file delete $FichierSql }
    set db [FabriqueDeTables $table "" misynpat.sql]

    set LsName [list AARS2 CARS2 DARS2 EARS2 FARS2 GARS HARS2 IARS2 KARS LARS2 MARS2 NARS2 PARS2 RARS2 SARS2 TARS2 VARS2 WARS2 YARS2]

    set LlName [list "Alanyl-tRNA synthetase" "Cysteinyl-tRNA synthetase" "Aspartyl-tRNA synthetase" "Glutamyl-tRNA synthetase" "Phenylalanyl-tRNA synthetase" "Glycyl-tRNA synthetase" "Histidyl-tRNA synthetase" "Isoleucyl-tRNA synthetase" "Lysyl-tRNA synthetase" "Leucyl-tRNA synthetase" "Methionyl-tRNA synthetase" "Asparaginyl-tRNA synthetase" "Prolyl-tRNA synthetase" "Arginyl-tRNA synthetase" "Seryl-tRNA synthetase" "Threonyl-tRNA synthetase" "Valyl-tRNA synthetase" "Tryptophanyl-tRNA synthetase" "Tyrosyl-tRNA synthetase"]

    set LpdbName [list AARS2 CARS2 "4AH6" EARS2 "3CMQ" GARS HARS2 IARS2 KARS LARS2 MARS2 NARS2 PARS2 RARS2 SARS2 TARS2 VARS2 WARS2 "2PID"]

    set Lclass [list "2" "1" "2" "1" "2" "2" "2" "1" "2" "1" "1" "2" "2" "1" "2" "2" "1" "1" "1"]

    set Laccess [list ]
    
    set Lsdisease [list "LBSL" "PCH6" "MLASA" "HUPRA" "PS" "ARSAL" "" "" "" "" "" "" "" "" "" ]
    
    set Lldisease [list "Leukoencephalopathy with Brain stem and Spinal cord involvement and Lactate elevation" "PontoCerebellar Hypoplasia type 6" "Myopathy, Lactic Acidosis and Sideroblastic Anemia" "HyperUricemia, Pulmonary hypertension and Renal failure in infancy and Alkalosis" "Perrault Syndrome" "Autosomal Recessive Spastic Ataxia with Leukoencephalopathy" "Early-onset Leukoencephalopathy with Thalamus and Brain stem involvment and high Lactate" "Infantil mitochondrial Alpers Encephalopathy" "Perrault Syndrome, with premature ovarian failure and hearing loss" "Early onset mt encephalopathy: microcephaly and epilepsy associated with isolated deficiency of the mt respiratory chain complex I" "Early onset mt encephalopathy: axial hypotonia and severe psychomotor delay associated with multiple mt respiratory chain defects" "Cataracts, growth hormone deficiency with short stature, partial sensorineural deafness, and peripheral neuropathy or Leigh Syndrome" "MERRF-like syndrome with severe myoclonic epilepsy, progressive spastic tetraparesis, impairment of vision, hearing and cognitive decline" "Leigh Syndrome with congenital auditory neuropathy and nonsyndromic hearing loss" "Infantil Mitochondrial Cardiomyopathy"]
    
    $db eval {begin transaction}
    set ::VariablesAuDepart [info globals]
    set Defauts(Mode) batch

    foreach s $LsName l $LlName c $Lclass {
	#set sys [string index $s 0]
	#set file [file join $MisyDir alignements ${sys}_VeryLastFinal.xml]
	#LoadingAlignment $file
	#"set seq [set ::Sequences($a)]
	#set ssg [string map {"." "" - ""} $seq]
	$db eval {insert into synthetase values (NULL,$s,$l,NULL,"20150101",$c,$ssg)}
    }
    foreach sd $Lsdisease ld $Lldisease {
	$db eval {insert into disease values (NULL,$sd,$ld,NULL,NULL)}
    }
    $db eval {commit}
    
    return
}

proc PubmedField {Pmid Field} {
    array set TInfo [eFetchREST pubmed $Pmid]
    parray TInfo
    if { ! [info exists TInfo($Pmid,$Field)]} { return "" }
    return $TInfo($Pmid,$Field)
}

proc SurveillancePubmed {{GetWhat ""} {AllFields ""}} {
    package require sqlite3
    package require tdom

    regsub -nocase GetNews    $GetWhat "GetNew"    GetWhat
    regsub -nocase GetResults $GetWhat "GetResult" GetWhat
    if {$AllFields==""} { set AllFields "AllFields" }
    set AllFields [string equal -nocase $AllFields "AllFields"]

    set WebServer "lbgi.fr"
    if {[info exists ::env] && [info exists ::env(HOST)]} {
	set Host [set ::env(HOST)]
	if {$Host=="bob"} {
	    set WebServer "misynpat.org"
	} else {
	    set WebServer "lbgi.fr"
	}
    }

    set Fichier "[MiSynPatDir]/misynpat.sql"
    set db "root"

    if {$AllFields} {
	set FieldSystemes    ""
	set FieldNecessaires ""
    } else {
	set FieldSystemes    "\[TIAB\]"
	set FieldNecessaires "\[TIAB\]"
    }

    set DateRange {"2007"[Date - Publication] : "3000"[Date - Publication]}

    set LesSystemes [list aars2 cars2 dars2 ears2 fars2 gars gars2 hars2 iars2 kars kars2 lars2 mars2 nars2 pars2 rars2 sars2 tars2 vars2 wars2 yars2]
    lappend LesSystemes mtARS
    set LaQuerySystemes {}
    foreach Term $LesSystemes {
	if {($Term=="gars" || $Term=="kars")} {
	    lappend LaQuerySystemes "\"$Term\"\[TIAB\]"
	} else {
	    lappend LaQuerySystemes "\"$Term\"$FieldSystemes"
	}
    }
    set QuerySystemes [join $LaQuerySystemes " OR "]

    set LesMotsNecessaires [list mutation mutations patient patients subject subjects disease diseases disorder disorders lbsl leukoencephalopathy]
    foreach Term $LesMotsNecessaires {
	lappend LaQueryMotsNecessaires "\"$Term\"$FieldNecessaires"
    }
    set QueryMotsNecessaires [join $LaQueryMotsNecessaires " OR "]
    
    set Langue {"English"[Language]}

    set QueryMitoSynMut "mitochondrial\[TIAB\] and aminoacyl-tRNA\[TIAB\] and synthetase\[TIAB\] and mutation*\[TIAB\]" 
    
    set Query "($DateRange) AND (($QueryMitoSynMut) OR (($QuerySystemes) AND ($QueryMotsNecessaires) NOT Kainate\[TIAB\] NOT Groningen\[TIAB\])) AND $Langue" 

    if {$GetWhat=="GetQuery"} { return $Query }
    set Query [list "[string map {"\"" "\\\""} $Query]"]
        
    set Lsearch [eSearchREST pubmed $Query]
    puts "\nLsearch $Lsearch"                   ; #rR repris de /home/moumou/mis.tcl 20210408
    set Lsearch [eSearchProcessXML $Lsearch]
    
    set LesKarsGarsMalTopes {} 
    foreach Ligne [LesLignesDuFichier "/home/ripp/msp/KarsTurkey.txt"] {
	scan $Ligne "%d" Pmid
	lappend LesKarsGarsMalTopes $Pmid
    }
    set Lsearch [ListsComplement $Lsearch $LesKarsGarsMalTopes]

    if {$GetWhat=="GetResult"} { return $Lsearch }
    

    sqlite3 $db $Fichier
    set Lold [$db eval {select pmid from biblio}]

    set Lnew [ListsComplement $Lsearch $Lold]
    puts "Lnew \n$Lnew"

    if {$GetWhat=="GetNew"} {
	return $Lnew
    }
    
    foreach Pmid $Lsearch {
	puts $Pmid
	set Title    [InfoPubmed $Lsearch $Pmid Title]
	set Abstract [InfoPubmed $Lsearch $Pmid Abstract]
	set PubYear  [InfoPubmed $Lsearch $Pmid PubYear]
	set PubMonth [InfoPubmed $Lsearch $Pmid PubMonth]
	
	set LesHitSysteme {}
	foreach Term $LesSystemes {
	    if {[regexp -nocase "\[^a-z\]$Term\[^a-z\]" " $Title "]}    { lappend LesHitSysteme $Term }
	    if {[regexp -nocase "\[^a-z\]$Term\[^a-z\]" " $Abstract "]} { lappend LesHitSysteme $Term }
	}
	set LesHitSysteme [lsort -unique $LesHitSysteme]
	
	set LesHitNecessaire {}
	foreach Term $LesMotsNecessaires {
	    if {[regexp -nocase "\[^a-z\]$Term\[^a-z\]" " $Title "]   } { lappend LesHitNecessaire $Term }
	    if {[regexp -nocase "\[^a-z\]$Term\[^a-z\]" " $Abstract "]} { lappend LesHitNecessaire $Term }
	}
	set LesHitNecessaire [lsort -unique $LesHitNecessaire]
	
	puts "" 
	puts "$Pmid $PubYear $PubMonth $Title"
	puts "I found $LesHitSysteme $LesHitNecessaire"
	set HitsTrouves($Pmid) [join [concat $LesHitSysteme $LesHitNecessaire]]
    }

    set adresse "m.sissler@iecb.u-bordeaux.fr,luc.moulinier@unistra.fr,raymond.ripp@unistra.fr"
    set sender "MiSynPat@$WebServer"
    if {$Lnew != {}} {
	set N [llength $Lnew]
	set sujet ">> $N New article"
	set corps "Hello !\n\n -> $N publication appears in the bibliographic system : Go to \nhttp://$WebServer/misynpat/BibliographyUpdate.rvt\n\n\nHave a good reading !"
	foreach new $Lnew {
	    set Hits ""
	    if {[info exists HitsTrouves($new)]} { set Hits $HitsTrouves($new) }
	    Espionne "new PMID : $new $Hits"
	    $db eval {insert into biblio values (NULL,$new,-1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,$Hits)}
	}
	# Record new articles in db
	AjouteEntreesBiblio $db
    } else {
	set sujet "From $WebServer : Nothing new in MiSynPat Bibliography."
	set corps "Hello !\n\nFrom $WebServer : Nothing new in MiSynPat Bibliography.\n\nSee you tomorrow !"
    }
    
    # check for unseen articles
    set NbUnseen [$db eval {select count(pk_biblio) from biblio where accepted = -1}]
    $db close

    if {$NbUnseen} {
	append sujet " $NbUnseen unseen articles !"
	set Message "BEWARE ! There are $NbUnseen articles that have not been processed !"
	append corps "\n$Message\n"
	puts $Message
    }
    send_simple_message $adresse localhost $sujet $corps $sender

    exit
}

proc AjouteEntreesBiblio {{db ""}} {
    if {$db==""} {
	set Fichier "[MiSynPatDir]/misynpat.sql"
	set db "root"
	sqlite3 $db $Fichier
    }

    set LesOk {}
    set pmids [$db eval {select pmid from biblio where accepted=-1}]
    foreach pmid $pmids {
	set Linfo [eFetchREST pubmed $pmid]
	array set Tinfo $Linfo
	Espionne $pmid
	if { ! [info exists Tinfo($pmid,Title)] && ! [info exists Tinfo($pmid,Abstract)] && ! [info exists Tinfo($pmid,PubYear)]} {
	    Espionne "$pmid rien trouvé : Linfo $Linfo"
	    continue
	}
	lappend LesOk $pmid

	set titre    $Tinfo($pmid,Title)
	set abstract $Tinfo($pmid,Abstract)
	set year     $Tinfo($pmid,PubYear)
	set month ""
	if {[info exists Tinfo($pmid,PubMonth)]} { set month $Tinfo($pmid,PubMonth) }

	Espionne "$pmid $year $month $titre"
	Espionne "$abstract"

	set titre    [string map {"'" "''"} $titre]
	set abstract [string map {"'" "''"} $abstract]
	
	$db eval {update biblio set abstract=$abstract,titre=$titre,datey=$year,datem=$month where pmid=$pmid}
	Espionne $pmid remis à jour dans database
    }

    return $LesOk
}

proc MiseAJourEntreesBiblio {{db ""} {PmidsSpecifiques ""}} {
    if {$db==""} {
	package require sqlite3
	set Fichier "[MiSynPatDir]/misynpat.sql"
	set db "root"
	sqlite3 $db $Fichier
    }
    set LesInfoDispo [list PubMonth Issue MeSHMinor Title LAuthors Abstract JrnAbbv MeSHMajor Volume PubYear Pages JrnName]
    set Corre(Issue)     ""
    set Corre(MeSHMinor) ""
    set Corre(MeSHMajor) ""
    set Corre(JrnName)   ""
    set Corre(Title)     titre
    set Corre(Abstract)  abstract
    set Corre(JrnAbbv)   sJournal
    set Corre(LAuthors)  auteurs
    set Corre(Volume)    volume
    set Corre(PubYear)   datey
    set Corre(PubMonth)  datem 
    set Corre(Pages)     pages

    set LesOk {}

    if {$PmidsSpecifiques!=""} {
	set pmids [split $PmidsSpecifiques ","]
    } else {
	set pmids [$db eval {select pmid from biblio}]
    }
    set pmids [lsort -unique $pmids]
    foreach pmid $pmids {
	set Tout [$db eval {select * from biblio where pmid=$pmid}]
	foreach K [list Pmid Accepted Abstract Journal Auteurs Pages Mois Annee Titre Volume Hits] {
	    set $K ""
	}
	lassign $Tout Pk Pmid Accepted Abstract Journal Auteurs Pages Mois Annee Titre Volume Hits 
	set ToutOk 1
	foreach K [list Pmid Accepted Abstract Auteurs Annee Titre] {
	    if {[set $K]==""} { set ToutOk 0 ; Espionne "$pmid $K" ; break }
	}
	if {$ToutOk} { continue }
	Espionne "$pmid"

	set Linfo [eFetchREST pubmed $pmid]
	if {[info exists Tinfo]} { unset Tinfo }
	array set Tinfo $Linfo
	if { ! [info exists Tinfo($pmid,Title)] && ! [info exists Tinfo($pmid,Abstract)] && ! [info exists Tinfo($pmid,PubYear)]} {
	    continue
	}
	lappend LesOk $pmid

	parray Tinfo

	set LesUpdate {}
	foreach I $LesInfoDispo {
	    if { ! [info exists Corre($I)] || $Corre($I)==""} { Espionne "pas de $I"           ; continue }
	    if { ! [info exists Tinfo($pmid,$I)]            } { Espionne "pas de info pour $I" ; continue }
	    set V $Tinfo($pmid,$I)
	    regsub -all "'" $V "''" V
	    lappend LesUpdate "$Corre($I)='$V'"
	}
	
	if {$LesUpdate!={}} {
	    set Update "update biblio set [join $LesUpdate ,] where pmid=$pmid"
	    Espionne $Update
	} 
	$db eval $Update
    }

    return $LesOk
}

proc Editdb {} {
    set Fichier "[MiSynPatDir]/misynpat.sql"
    set db "root"
    sqlite3 $db $Fichier
    set pks [$db eval {select pk_synthetase from synthetase}]
    foreach pk $pks {
	$db eval {insert into jmol values ($pk,NULL,NULL,NULL,NULL,NULL)}
    }
    $db close
}


proc testdb {} {
    set Fichier "[MiSynPatDir]/misynpat.sql"
    set db "root"
    sqlite3 $db $Fichier
    set Nom "DARS2"
    set Lfeat [$db eval {select seq from synthetase where sName=$Nom}]
    set pk [$db eval {select pk_synthetase from synthetase where sName=$Nom}]
    set muta [$db eval {select pk_mutation from mutation where pk_synthetase=$pk}]
    set variant {}
    
    foreach mut $muta {
	set var1 [$db eval {select variant1 from mutation where pk_mutation=$mut}]
	set var2 [$db eval {select variant2 from mutation where pk_mutation=$mut}]
	if {$var1 ne "X1X" && $var1 ne "X2X" } {lappend variant "$var1"}
	if {$var2 ne "X1X" && $var2 ne "X2X" } {lappend variant "$var2"}
    }
    regsub -all {[A-Z]} $variant {} variant
    set variant [lsort -unique $variant]
    set variant [join $variant ","]
    set Lfeat [join $Lfeat ""]
    set Lfeat [split $Lfeat ","]
    
    foreach feat $Lfeat {
	if {[regexp {'([0-9]+)'} $feat]} {continue}
	regsub -all {'} $feat {} feat	
	set feats [split $feat " "]
	set start [expr { round([lindex $feat 1]*0.25) }]
	set stop [expr { round([lindex $feat 2]*0.25) }]
	set lenrect [expr { round($stop-$start) }]
	puts $lenrect
	
    }
}
proc Testcode {} {
    source /home/moumou/ordali/src/ordali_misynpat.tcl
    set sys "dars2"
    set pos "512"
    set aa "P"
    
    set retour [ComputeMiSynPatMutation $sys $pos $aa]
    puts "$retour"
    exit

}